tonightpass/dist/index.d.ts

@tonightpass sdk and tools.

import * as pathcat from 'pathcat';
import { Query, ParamValue } from 'pathcat';
export * from 'pathcat';
import { Options, Response as Response$1 } from 'redaxios';
import { ValidatorConstraintInterface, ValidationArguments, ValidationOptions } from 'class-validator';
import * as Stripe from 'stripe';
import Stripe__default from 'stripe';
import { HealthCheckResult, HealthIndicatorResult } from '@nestjs/terminus';

declare const DEFAULT_API_URL = "https://api.tonightpass.com";

declare const REGEX: {
    EMAIL: RegExp;
    INLINE: {
        EMAIL: RegExp;
        URL: RegExp;
        USER_MENTION: RegExp;
        ARTIST_MENTION: RegExp;
    };
    NAME: RegExp;
    SLUG: RegExp;
    USERNAME: RegExp;
    PHONE: RegExp;
    PASSWORD: RegExp;
    PASSWORD_MIN_LENGTH: RegExp;
    PASSWORD_UPPERCASE: RegExp;
    PASSWORD_LOWERCASE: RegExp;
    PASSWORD_NUMBER_SPECIAL: RegExp;
    IMAGE_URL: RegExp;
    ORGANIZATION_AVATAR_URL: RegExp;
    ORGANIZATION_BANNER_URL: RegExp;
    EVENT_FLYER_URL: RegExp;
    EVENT_FLYER_URL_UPDATE: RegExp;
    EVENT_TRAILER_URL: RegExp;
    EVENT_TRAILER_URL_UPDATE: RegExp;
    USER_AVATAR_URL: RegExp;
    USER_AVATAR_URL_CREATE: RegExp;
    USER_BANNER_URL: RegExp;
    CHANNEL_MESSAGE_ATTACHMENT: RegExp;
    USER_POST_MEDIA_URL: RegExp;
};

type ArtistSoundcloudBadges = {
    pro: boolean;
    proUnlimited: boolean;
    verified: boolean;
};
type ArtistSoundcloudWebProfile = {
    network: string;
    url: string;
    title?: string;
    username?: string;
};
type ArtistTrack = {
    id: string;
    title: string;
    permalinkUrl: string;
    artworkUrl?: string;
    duration: number;
    playbackCount: number;
    likesCount: number;
    genre?: string;
    createdAt: string;
};
type ArtistSoundcloudData = {
    permalinkUrl: string;
    followersCount: number;
    followingsCount: number;
    trackCount: number;
    playlistCount: number;
    likesCount: number;
    badges: ArtistSoundcloudBadges;
    webProfiles: ArtistSoundcloudWebProfile[];
};
type ArtistTonightPassData = {
    followersCount: number;
    isFollowing: boolean;
};
type Artist = {
    id: string;
    username: string;
    permalink: string;
    fullName?: string;
    city?: string;
    countryCode?: string;
    description?: string;
    avatarUrl: string;
    bannerUrl?: string;
    soundcloud: ArtistSoundcloudData;
    tonightpass: ArtistTonightPassData;
};
type ArtistWithTracks = Omit<Artist, "soundcloud"> & {
    soundcloud: ArtistSoundcloudData & {
        tracks: ArtistTrack[];
        topTracks: ArtistTrack[];
    };
};
type EventArtistRef = {
    id: string;
    permalink: string;
    username: string;
};
type SearchArtistsOptions = ArrayOptions<Artist> & {
    q: string;
};
type GetArtistOptions = {
    trackLimit?: number;
};
type ListArtistEventsOptions = ArrayOptions<OrganizationEvent> & {
    upcoming?: boolean;
};
type ListTopArtistsOptions = ArrayOptions<Artist>;
type ArtistEndpoints = Endpoint<"GET", "/artists/top", ArrayResult<Artist>, ListTopArtistsOptions> | Endpoint<"GET", "/artists/search", ArrayResult<Artist>, SearchArtistsOptions> | Endpoint<"GET", "/artists/:idOrPermalink", ArtistWithTracks, GetArtistOptions> | Endpoint<"POST", "/artists/:idOrPermalink/follow", {
    isFollowing: boolean;
}> | Endpoint<"DELETE", "/artists/:idOrPermalink/follow", {
    isFollowing: boolean;
}> | Endpoint<"GET", "/artists/:idOrPermalink/events", ArrayResult<OrganizationEvent>, ListArtistEventsOptions>;

declare enum UserNotificationType {
    Follow = "follow"
}
type UserNotificationBase = Base & {
    type: UserNotificationType.Follow;
    isSeen: boolean;
};
type UserNotificationFollow = UserNotificationBase & {
    type: UserNotificationType.Follow;
    follower: UserProfile;
};
type UserNotification = UserNotificationFollow;
type UserNotificationEndpoints = Endpoint<"GET", "/users/~me/notifications", ArrayResult<UserNotification>, ArrayOptions<UserNotification>> | Endpoint<"GET", "/users/~me/notifications/count", number, {
    unseen?: boolean;
}> | Endpoint<"PUT", "/users/~me/notifications/read", void, undefined>;

declare class CreateUserPostCommentDto {
    content: string;
    replyToId?: string;
}

declare class UpdateUserPostCommentDto {
    content: string;
}

declare class CreateUserPostDto {
    content?: string;
    mediaUrls: string[];
    visibility?: UserPostVisibility;
}

declare class CreateUserPostRepostDto {
    comment?: string;
}

declare class UpdateUserPostDto {
    content?: string;
    visibility?: UserPostVisibility;
}

type UserPostComment = Base & {
    post: UserPost;
    author: UserProfile;
    content: string;
    replyTo?: UserPostComment;
    isEdited: boolean;
    editedAt?: Date;
};
type UserPostCommentEndpoints = Endpoint<"GET", "/users/@:username/posts/:postId/comments", ArrayResult<UserPostComment>, ArrayOptions<UserPostComment>> | Endpoint<"POST", "/users/~me/posts/:postId/comments", UserPostComment, CreateUserPostCommentDto> | Endpoint<"PUT", "/users/~me/posts/:postId/comments/:commentId", UserPostComment, UpdateUserPostCommentDto> | Endpoint<"DELETE", "/users/~me/posts/:postId/comments/:commentId", void, null>;

declare enum UserPostMediaType {
    Image = "image",
    Video = "video"
}
type UserPostMedia = {
    url: string;
    type: UserPostMediaType;
    width: number;
    height: number;
    description?: string;
    isNSFW: boolean;
    thumbnailUrl?: string;
    duration?: number;
};
type UserPostMediaEndpoints = Endpoint<"POST", "/users/~me/posts/media", string, FormData>;

type UserPostRepost = Base & {
    originalPost: UserPost;
    author: UserProfile;
    comment?: string;
};
type UserPostRepostEndpoints = Endpoint<"GET", "/users/@:username/reposts", ArrayResult<UserPostRepost>, ArrayOptions<UserPostRepost>> | Endpoint<"GET", "/users/@:username/posts/:postId/reposts", ArrayResult<UserPostRepost>, ArrayOptions<UserPostRepost>> | Endpoint<"POST", "/users/~me/posts/:postId/reposts", UserPostRepost, CreateUserPostRepostDto> | Endpoint<"DELETE", "/users/~me/posts/:postId/reposts", void, undefined>;

type UserPostViewOptions = {
    posts: string | string[];
};
type UserPostViewResult = {
    postId: string;
    visitsCount: number;
};
type UserPostViewEndpoints = Endpoint<"POST", "/users/@:username/posts/:postId/views", boolean, null> | Endpoint<"GET", "/users/posts/views/stream", ReadableStream<UserPostViewResult>, UserPostViewOptions>;

declare enum UserPostVisibility {
    Public = "public",
    Followers = "followers",
    Private = "private"
}
type UserPost = Base & {
    author: UserProfile;
    content?: string;
    media: UserPostMedia[];
    visibility: UserPostVisibility;
    metrics: {
        reposts: number;
        comments: number;
        views: number;
        visits: number;
        visitors: number;
    };
    isReposted?: boolean;
    isEdited: boolean;
    editedAt?: Date;
};
type UserPostEndpoints = Endpoint<"GET", "/users/@:username/posts", ArrayResult<UserPost>, ArrayOptions<UserPost>> | Endpoint<"GET", "/users/@:username/posts/:postId", UserPost> | Endpoint<"POST", "/users/~me/posts", UserPost, CreateUserPostDto> | Endpoint<"PUT", "/users/~me/posts/:postId", UserPost, UpdateUserPostDto> | Endpoint<"DELETE", "/users/~me/posts/:postId", void, undefined> | UserPostCommentEndpoints | UserPostRepostEndpoints | UserPostViewEndpoints | UserPostMediaEndpoints;

/**
 * All currencies supported by Stripe for card payments.
 * Source: https://docs.stripe.com/currencies#presentment-currencies
 */
declare enum Currency {
    USD = "USD",
    EUR = "EUR",
    GBP = "GBP",
    ARS = "ARS",
    AWG = "AWG",
    BBD = "BBD",
    BMD = "BMD",
    BOB = "BOB",
    BRL = "BRL",
    BSD = "BSD",
    BZD = "BZD",
    CAD = "CAD",
    CLP = "CLP",
    COP = "COP",
    CRC = "CRC",
    DOP = "DOP",
    FKP = "FKP",
    GTQ = "GTQ",
    GYD = "GYD",
    HNL = "HNL",
    HTG = "HTG",
    JMD = "JMD",
    KYD = "KYD",
    MXN = "MXN",
    NIO = "NIO",
    PAB = "PAB",
    PEN = "PEN",
    PYG = "PYG",
    SRD = "SRD",
    TTD = "TTD",
    UYU = "UYU",
    XCD = "XCD",
    ALL = "ALL",
    BAM = "BAM",
    BGN = "BGN",
    BYN = "BYN",
    CHF = "CHF",
    CZK = "CZK",
    DKK = "DKK",
    GEL = "GEL",
    GIP = "GIP",
    HUF = "HUF",
    ISK = "ISK",
    MDL = "MDL",
    MKD = "MKD",
    NOK = "NOK",
    PLN = "PLN",
    RON = "RON",
    RSD = "RSD",
    RUB = "RUB",
    SEK = "SEK",
    TRY = "TRY",
    UAH = "UAH",
    AED = "AED",
    AFN = "AFN",
    AMD = "AMD",
    AZN = "AZN",
    BDT = "BDT",
    BND = "BND",
    CNY = "CNY",
    HKD = "HKD",
    IDR = "IDR",
    ILS = "ILS",
    INR = "INR",
    JPY = "JPY",
    KGS = "KGS",
    KHR = "KHR",
    KRW = "KRW",
    KZT = "KZT",
    LAK = "LAK",
    LBP = "LBP",
    LKR = "LKR",
    MMK = "MMK",
    MNT = "MNT",
    MOP = "MOP",
    MVR = "MVR",
    MYR = "MYR",
    NPR = "NPR",
    PHP = "PHP",
    PKR = "PKR",
    QAR = "QAR",
    SAR = "SAR",
    SGD = "SGD",
    THB = "THB",
    TJS = "TJS",
    TWD = "TWD",
    UZS = "UZS",
    VND = "VND",
    YER = "YER",
    AOA = "AOA",
    BWP = "BWP",
    CDF = "CDF",
    CVE = "CVE",
    DJF = "DJF",
    DZD = "DZD",
    EGP = "EGP",
    ETB = "ETB",
    GMD = "GMD",
    GNF = "GNF",
    KES = "KES",
    KMF = "KMF",
    LRD = "LRD",
    LSL = "LSL",
    MAD = "MAD",
    MGA = "MGA",
    MUR = "MUR",
    MWK = "MWK",
    MZN = "MZN",
    NAD = "NAD",
    NGN = "NGN",
    RWF = "RWF",
    SCR = "SCR",
    SHP = "SHP",
    SLE = "SLE",
    SOS = "SOS",
    STD = "STD",
    SZL = "SZL",
    TZS = "TZS",
    UGX = "UGX",
    XAF = "XAF",
    XOF = "XOF",
    ZAR = "ZAR",
    ZMW = "ZMW",
    ANG = "ANG",
    AUD = "AUD",
    BIF = "BIF",
    FJD = "FJD",
    NZD = "NZD",
    PGK = "PGK",
    SBD = "SBD",
    TOP = "TOP",
    VUV = "VUV",
    WST = "WST",
    XCG = "XCG",
    XPF = "XPF"
}
/**
 * Zero-decimal currencies have no minor units (no cents).
 * Amounts are specified in the major unit directly (e.g., 500 JPY = 500 yen).
 * Source: https://docs.stripe.com/currencies#zero-decimal
 */
declare const ZERO_DECIMAL_CURRENCIES: Currency[];
/**
 * Minimum charge amounts per currency (in smallest unit).
 * Source: https://docs.stripe.com/currencies#minimum-and-maximum-charge-amounts
 */
declare const MINIMUM_CHARGE_AMOUNTS: Partial<Record<Currency, number>>;
type ExchangeRates = {
    base: Currency.EUR;
    rates: Record<Currency, number>;
    updatedAt: Date;
};
type CurrencyConversion = {
    from: Currency;
    to: Currency;
    amount: number;
};
type CurrencyConversionResult = {
    originalAmount: number;
    originalCurrency: Currency;
    convertedAmount: number;
    targetCurrency: Currency;
    exchangeRate: number;
    convertedAt: Date;
};
type CurrenciesEndpoints = Endpoint<"GET", "/currencies/rates", ExchangeRates> | Endpoint<"POST", "/currencies/convert", CurrencyConversionResult, CurrencyConversion>;

type OrganizationEventPromoCode = Base & {
    code: string;
    type: OrganizationEventPromoCodeType;
    value: number;
    maxUses?: number;
    usedCount: number;
    isActive: boolean;
    minCartAmount?: number;
    expiresAt?: Date;
    ticketIds?: string[];
};
declare enum OrganizationEventPromoCodeType {
    Percentage = "percentage",
    Fixed = "fixed"
}
type OrganizationEventPromoCodeValidation = {
    valid: boolean;
    promoCode?: OrganizationEventPromoCode;
    message?: string;
};
type OrganizationEventPromoCodeEndpoints = Endpoint<"GET", "/organizations/@:organizationSlug/events/:eventSlug/promo-codes", ArrayResult<OrganizationEventPromoCode>, ArrayOptions<OrganizationEventPromoCode>> | Endpoint<"POST", "/organizations/@:organizationSlug/events/:eventSlug/promo-codes", OrganizationEventPromoCode, CreateOrganizationEventPromoCodeDto> | Endpoint<"PUT", "/organizations/@:organizationSlug/events/:eventSlug/promo-codes/:promoCodeId", OrganizationEventPromoCode, UpdateOrganizationEventPromoCodeDto> | Endpoint<"DELETE", "/organizations/@:organizationSlug/events/:eventSlug/promo-codes/:promoCodeId", OrganizationEventPromoCode, null> | Endpoint<"POST", "/organizations/@:organizationSlug/events/:eventSlug/promo-codes/validate", OrganizationEventPromoCodeValidation, {
    code: string;
}>;

type OrderItem = {
    ticketId: string;
    ticketName: string;
    quantity: number;
    unitAmount: number;
    totalAmount: number;
};
declare enum OrderTransferStatus {
    Completed = "completed",
    Pending = "pending",
    Transferred = "transferred"
}
type OrderDiscount = {
    code: string;
    type: OrganizationEventPromoCodeType;
    value: number;
    amount: number;
};
type Order = Base & {
    paymentIntent: Stripe__default.PaymentIntent;
    items: OrderItem[];
    currency: Currency;
    subtotal: number;
    discount?: OrderDiscount;
    fee: number;
    total: number;
    transferStatus: OrderTransferStatus;
    user: UserProfile;
};
type OrderEndpoints = Endpoint<"GET", "/orders", ArrayResult<Order>, ArrayOptions<Order>> | Endpoint<"GET", "/orders/:orderId", Order>;

type UserBookingTicket = Base & {
    booking: UserBookingWithoutTickets;
    ticket: OrganizationEventTicket;
    token: UserToken;
    useCount: number;
};
type UserBookingTicketEndpoints = Endpoint<"GET", "/users/bookings/tickets/:ticketId", UserBookingTicket, {
    tokenId: string;
    tokenValue: string;
}> | Endpoint<"PUT", "/users/bookings/tickets/:ticketId/use", UserBookingTicket, {
    tokenId: string;
    tokenValue: string;
}>;

type UserBookingWithoutTickets = Omit<UserBooking, "tickets">;
type UserBooking = Base & {
    tickets: UserBookingTicket[];
    order: Order;
    customer: OrganizationCustomer;
    event: OrganizationEvent;
};
type UserBookingEndpoints = Endpoint<"GET", "/users/bookings", ArrayResult<UserBooking>, ArrayOptions<UserBooking>> | Endpoint<"GET", "/users/~me/bookings", ArrayResult<UserBooking>, ArrayOptions<UserBooking>> | Endpoint<"GET", "/users/@:userId/bookings", ArrayResult<UserBooking>, ArrayOptions<UserBooking>> | Endpoint<"GET", "/users/bookings/:bookingId", UserBooking> | Endpoint<"GET", "/users/~me/bookings/:bookingId", UserBooking> | UserBookingTicketEndpoints;

declare enum ProfileType {
    User = "user",
    Organization = "organization"
}
type BaseProfile = {
    type: ProfileType;
    slug: string;
    displayName: string;
    description?: string;
    avatarUrl?: string;
    bannerUrl?: string;
    links: string[];
    metadata: ProfileMetadata;
    createdAt: Date;
};
type UserProfile = BaseProfile & {
    type: ProfileType.User;
    metadata: UserProfileMetadata;
};
type OrganizationProfile = BaseProfile & {
    type: ProfileType.Organization;
    metadata: OrganizationProfileMetadata;
};
type Profile = UserProfile | OrganizationProfile;
type BaseProfileMetadata = {
    followersCount: number;
    isFollower: boolean;
    isFollowing: boolean;
    isBlocked: boolean;
    hasBlocked: boolean;
    canDM: boolean;
    isOfficial: boolean;
};
type UserProfileMetadata = BaseProfileMetadata & {
    hasPassPlus: boolean;
};
type OrganizationProfileMetadata = BaseProfileMetadata & {
    eventsCount: number;
    viewsCount: number;
    visitsCount: number;
    visitorsCount: number;
    membersCount: number;
};
type ProfileMetadata = UserProfileMetadata | OrganizationProfileMetadata;
type SearchProfilesOptions = ArrayOptions<Profile> & {
    q: string;
};
type ProfileEndpoints = Endpoint<"GET", "/profiles", ArrayResult<Profile>, ArrayOptions<Profile>> | Endpoint<"GET", "/profiles/search", ArrayResult<Profile>, SearchProfilesOptions> | Endpoint<"GET", "/profiles/@:username", Profile> | Endpoint<"GET", "/profiles/~me/relationships/suggestions", ArrayResult<Profile>, ArrayOptions<OrganizationProfile | UserProfile>> | Endpoint<"GET", "/profiles/@:username/relationships/followers", ArrayResult<UserProfile>, ArrayOptions<UserProfile>> | Endpoint<"POST", "/profiles/@:username/relationships/follow", boolean, undefined> | Endpoint<"POST", "/profiles/@:username/relationships/unfollow", boolean, undefined>;

type UserCustomer = UserProfile & {
    email?: string;
    phoneNumber?: string;
    firstName: string;
    lastName: string;
    fullName: string;
    metadata: UserCustomerMetadata;
};
type UserCustomerMetadata = UserProfileMetadata & {
    bookingsCount: number;
    eventsAttendedCount: number;
    totalSpent: number;
    lastBookingAt?: Date;
};

type UserToken = Omit<Base, "updatedAt"> & {
    type: UserTokenType;
    value: string;
    expiresAt: Date;
    user?: User;
    identifier?: string;
};
declare enum UserTokenType {
    Authentication = "authentication",
    BookingTicket = "booking_ticket",
    OrganizationInvite = "organization_invite",
    PasswordRecovery = "password_recovery",
    EmailValidation = "email_validation",
    PhoneValidation = "phone_validation"
}

type User = Base & {
    identifier: UserIdentifier;
    password?: string;
    identity: UserIdentity;
    role: UserRole;
    addresses: Location$1[];
    preferences: UserPreferences;
    connections: UserConnection[];
    oauthProviders: UserOAuthProvider[];
    isVerified: boolean;
    isOfficial: boolean;
};
type UserIdentifier = {
    email?: string;
    emailVerified?: boolean;
    phoneNumber?: string;
    phoneNumberVerified?: boolean;
    username: string;
};
type UserIdentity = UserProfile & {
    firstName: string;
    lastName: string;
    fullName: string;
    gender: UserIdentityGender;
    birthDate: Date;
    birthDateLastUpdatedAt?: Date;
};
declare enum UserRole {
    User = "user",
    Developer = "developer",
    Admin = "admin"
}
declare enum UserIdentityGender {
    Male = "male",
    Female = "female",
    NonBinary = "non-binary"
}
type UserPreferences = {
    language: Language;
    currency: Currency;
    notifications: {
        email: {
            newsletter: boolean;
            message: boolean;
        };
        push: {
            message: boolean;
        };
    };
};
type UserConnection = {
    ip: string;
    os: UserConnectionOS;
    device: UserConnectionDevice;
    client: UserConnectionClient;
    updatedAt: Date;
    createdAt: Date;
};
type UserOAuthProvider = Base & {
    provider: OAuth2Provider;
    providerId: string;
    displayName?: string;
    username?: string;
    email?: string;
    emailVerified: boolean;
    lastUsedAt?: Date;
};
type UserConnectionOS = {
    name: string;
    version: string;
};
type UserConnectionDevice = {
    type: string;
    brand: string;
};
type UserConnectionClient = {
    name: string;
    version: string;
};
declare enum UserFileType {
    Avatar = "avatar",
    Banner = "banner"
}
type UserEndpoints = Endpoint<"GET", "/users", User[]> | Endpoint<"GET", "/users/@:userId", User> | Endpoint<"GET", "/users/~me", User> | Endpoint<"GET", "/users/check/:identifier", {
    exists: boolean;
    identifier: Partial<UserIdentifier>;
    suggestions?: string[];
}, {
    identifier: boolean;
    suggestions?: boolean;
}> | Endpoint<"PUT", "/users/@:userId", User, UpdateUserDto> | Endpoint<"POST", "/users/@:userId/files/:userFileType", string, FormData> | Endpoint<"POST", "/users/files/:userFileType", string, FormData> | UserBookingEndpoints | UserNotificationEndpoints | UserPostEndpoints;

declare enum OAuth2Provider {
    Google = "google",
    Facebook = "facebook",
    Twitter = "twitter"
}
type AuthMethod = OAuth2Provider | "password";
declare enum AuthFlow {
    SignUp = "signup",
    SignIn = "signin"
}
type RecoveryResponse = {
    to: string;
};
type VerifyEmailResponse = {
    to: string;
};
type AuthResponse = {
    user: User;
    accessToken: string;
    refreshToken: string;
    flow: AuthFlow;
};
type AuthEndpoints = Endpoint<"POST", "/auth/sign-up", AuthResponse, CreateUserDto> | Endpoint<"POST", "/auth/sign-in", AuthResponse, SignInUserDto> | Endpoint<"POST", "/auth/sign-out", null, undefined> | Endpoint<"POST", "/auth/refresh-token", AuthResponse, undefined> | Endpoint<"POST", "/auth/recovery", RecoveryResponse, RecoveryDto> | Endpoint<"POST", "/auth/recovery/reset", null, RecoveryResetDto> | Endpoint<"GET", "/oauth2/:provider", void> | Endpoint<"GET", "/oauth2/:provider/callback", void> | Endpoint<"GET", `/oauth2/${OAuth2Provider.Google}`, void> | Endpoint<"GET", `/oauth2/${OAuth2Provider.Google}/callback`, void> | Endpoint<"POST", `/oauth2/${OAuth2Provider.Google}/one-tap`, AuthResponse, GoogleOneTapDto> | Endpoint<"GET", `/oauth2/${OAuth2Provider.Facebook}`, void> | Endpoint<"GET", `/oauth2/${OAuth2Provider.Facebook}/callback`, void> | Endpoint<"GET", `/oauth2/${OAuth2Provider.Twitter}`, void> | Endpoint<"GET", `/oauth2/${OAuth2Provider.Twitter}/callback`, void> | Endpoint<"DELETE", "/oauth2/:provider", void, undefined> | Endpoint<"POST", "/auth/verify/email/send", VerifyEmailResponse, undefined> | Endpoint<"POST", "/auth/verify/email/confirm", null, VerifyEmailConfirmDto>;

type CareersOffice = {
    id: number | null;
    isDefault: boolean | null;
    name: string | null;
    city: string | null;
    countryIso: string | null;
};
declare enum CareersJobStatus {
    All = "ALL",
    Online = "ONLINE",
    Archived = "ARCHIVED"
}
declare enum CareersWorkplaceType {
    Onsite = "ONSITE",
    Remote = "REMOTE",
    Hybrid = "HYBRID"
}
declare enum CareersRemoteType {
    Anywhere = "ANYWHERE",
    Country = "COUNTRY"
}
type CareersJob = {
    id: number;
    createdAt: string;
    lastUpdatedAt: string;
    externalId: null | string;
    title: string;
    status: CareersJobStatus;
    remote: boolean;
    office: CareersOffice;
    workplaceType: CareersWorkplaceType;
    remoteType?: CareersRemoteType;
    description?: string;
    categoryId?: number;
    employmentTypeId?: number;
};
type CareersCategory = {
    slug: string;
    name: string;
    subCategories?: (CareersCategory & {
        id: number;
    })[];
};
type CareersEmploymentType = {
    id: number;
    name: string;
    slug: string;
};
type CareersJobsOptions = ArrayOptions<CareersJob> & {
    createdAtGte?: string;
    createdAtLt?: string;
    updatedAtGte?: string;
    updatedAtLt?: string;
    status?: CareersJobStatus;
    content?: boolean;
    titleLike?: string;
    countryCode?: string;
    externalId?: string;
};
type CareersOfficesOptions = ArrayOptions<CareersOffice> & {
    countryCode?: string;
    cityNameLike?: string;
};
type CareersCategoriesOptions = ArrayOptions<CareersCategory> & {
    language?: string;
};
type CareersEmploymentTypesOptions = ArrayOptions<CareersEmploymentType> & {
    language?: string;
};
type CareerEndpoints = Endpoint<"GET", "/careers/categories", ArrayResult<CareersCategory>, CareersCategoriesOptions> | Endpoint<"GET", "/careers/employmentTypes", ArrayResult<CareersEmploymentType>, CareersEmploymentTypesOptions> | Endpoint<"GET", "/careers/jobs", ArrayResult<CareersJob>, CareersJobsOptions> | Endpoint<"GET", "/careers/jobs/:jobId", CareersJob, {
    jobId: number;
}> | Endpoint<"GET", "/careers/offices", ArrayResult<CareersOffice>, CareersOfficesOptions>;

declare enum ChannelMessageReportReason {
    Dislike = "dislike",
    HarassmentSelf = "harassment_self",
    HarassmentOther = "harassment_other",
    SexualHarassmentSelf = "sexual_harassment_self",
    NudesSelf = "nudes_self",
    SexualContent = "sexual_content",
    ChildInvolved = "child_involved",
    ThreatTarget = "threat_target",
    ViolentContent = "violent_content",
    HateSpeech = "hate_speech",
    Terrorism = "terrorism",
    DrugSale = "drug_sale",
    WeaponSale = "weapon_sale",
    SelfHarmConcern = "self_harm_concern",
    SelfHarmPromotion = "self_harm_promotion",
    Other = "other"
}
type ChannelMessageReadByEntry = {
    participant: ChannelParticipant;
    readAt: Date;
};
type ChannelMessageReaction = {
    emoji: string;
    participants: ChannelParticipant[];
};
type ChannelMessage = Base & {
    channel: Channel;
    sender: ChannelParticipant;
    content?: string;
    attachments: string[];
    isSent: boolean;
    isDelivered: boolean;
    isRead: boolean;
    readBy?: ChannelMessageReadByEntry[];
    isEdited: boolean;
    editedAt?: Date;
    replyTo?: ChannelMessage;
    reactions?: ChannelMessageReaction[];
};
type ChannelMessageEndpoints = Endpoint<"GET", "/channels/~me/:channelId/messages", ArrayResult<ChannelMessage>, ArrayOptions<ChannelMessage>> | Endpoint<"GET", "/channels/:organizationSlug/:channelId/messages", ArrayResult<ChannelMessage>, ArrayOptions<ChannelMessage>> | Endpoint<"GET", "/channels/~me/:channelId/messages/:messageId", ChannelMessage> | Endpoint<"GET", "/channels/:organizationSlug/:channelId/messages/:messageId", ChannelMessage> | Endpoint<"POST", "/channels/~me/:channelId/messages", ChannelMessage, CreateChannelMessageDto> | Endpoint<"POST", "/channels/:organizationSlug/:channelId/messages", ChannelMessage, CreateChannelMessageDto> | Endpoint<"PUT", "/channels/~me/:channelId/messages/:messageId", ChannelMessage, UpdateChannelMessageDto> | Endpoint<"PUT", "/channels/:organizationSlug/:channelId/messages/:messageId", ChannelMessage, UpdateChannelMessageDto> | Endpoint<"DELETE", "/channels/~me/:channelId/messages/:messageId", void, undefined> | Endpoint<"DELETE", "/channels/:organizationSlug/:channelId/messages/:messageId", void, undefined> | Endpoint<"POST", "/channels/~me/:channelId/messages/:messageId/reactions", void, AddReactionDto> | Endpoint<"POST", "/channels/:organizationSlug/:channelId/messages/:messageId/reactions", void, AddReactionDto> | Endpoint<"DELETE", "/channels/~me/:channelId/messages/:messageId/reactions/:emoji", void, undefined> | Endpoint<"DELETE", "/channels/:organizationSlug/:channelId/messages/:messageId/reactions/:emoji", void, undefined> | Endpoint<"POST", "/channels/~me/:channelId/messages/:messageId/read", void, undefined> | Endpoint<"POST", "/channels/:organizationSlug/:channelId/messages/:messageId/read", void, undefined> | Endpoint<"POST", "/channels/~me/:channelId/files", string, FormData> | Endpoint<"POST", "/channels/:organizationSlug/:channelId/files", string, FormData> | Endpoint<"POST", "/channels/~me/:channelId/messages/:messageId/report", void, ReportChannelMessageDto> | Endpoint<"POST", "/channels/:organizationSlug/:channelId/messages/:messageId/report", void, ReportChannelMessageDto>;

declare enum ChannelType {
    Private = "private",
    Group = "group"
}
declare enum ChannelMemberRole {
    Member = "member",
    Admin = "admin"
}
type ChannelParticipant = Profile;
declare enum ChannelStatus {
    Sent = "sent",
    Delivered = "delivered",
    Read = "read",
    Received = "received",
    Opened = "opened"
}
type Channel = Base & {
    type: ChannelType;
    participants: ChannelParticipant[];
    name?: string;
    lastMessageAt?: Date;
    status?: ChannelStatus;
    unreadCount?: number;
};
type ChannelMember = {
    participant: ChannelParticipant;
    joinedAt: Date;
    role?: ChannelMemberRole;
    lastReadAt?: Date;
};
type UserChannelCountOptions = {
    unseen?: boolean;
};
type ChannelEndpoints = Endpoint<"GET", "/channels/~me", ArrayResult<Channel>, ArrayOptions<Channel>> | Endpoint<"GET", "/channels/:organizationSlug", ArrayResult<Channel>, ArrayOptions<Channel>> | Endpoint<"GET", "/users/~me/channels/count", number, UserChannelCountOptions> | Endpoint<"GET", "/users/@:organizationSlug/channels/count", number, UserChannelCountOptions> | Endpoint<"GET", "/channels/~me/:channelId", Channel> | Endpoint<"GET", "/channels/:organizationSlug/:channelId", Channel> | Endpoint<"POST", "/channels/~me", Channel, CreateChannelDto> | Endpoint<"POST", "/channels/:organizationSlug", Channel, CreateChannelDto> | Endpoint<"PUT", "/channels/~me/:channelId", Channel, UpdateChannelDto> | Endpoint<"PUT", "/channels/:organizationSlug/:channelId", Channel, UpdateChannelDto> | Endpoint<"DELETE", "/channels/~me/:channelId", void, undefined> | Endpoint<"DELETE", "/channels/:organizationSlug/:channelId", void, undefined> | Endpoint<"POST", "/channels/~me/:channelId/participants", void, AddParticipantDto> | Endpoint<"POST", "/channels/:organizationSlug/:channelId/participants", void, AddParticipantDto> | Endpoint<"DELETE", "/channels/~me/:channelId/participants/:username", void, undefined> | Endpoint<"DELETE", "/channels/:organizationSlug/:channelId/participants/:username", void, undefined> | Endpoint<"GET", "/channels/~me/:channelId/members", ArrayResult<ChannelMember>, ArrayOptions<ChannelMember>> | Endpoint<"GET", "/channels/:organizationSlug/:channelId/members", ArrayResult<ChannelMember>, ArrayOptions<ChannelMember>>;

declare enum ErrorType {
    AuthEmailAlreadyExists = "auth.email-already-exists",
    AuthUsernameAlreadyExists = "auth.username-already-exists",
    AuthPhoneNumberAlreadyExists = "auth.phone-number-already-exists",
    AuthInvalidCredentials = "auth.invalid-credentials",
    AuthUserNotFound = "auth.user-not-found",
    AuthInvalidToken = "auth.invalid-token",
    AuthTokenExpired = "auth.token-expired",
    AuthUnauthorized = "auth.unauthorized",
    AuthPasswordMismatch = "auth.password-mismatch",
    AuthInvalidOAuth2Provider = "auth.invalid-oauth2-provider",
    AuthOAuth2Error = "auth.oauth2-error",
    UserNotFound = "user.not-found",
    UserInvalidUsername = "user.invalid-username",
    UserInvalidEmail = "user.invalid-email",
    UserInvalidPhoneNumber = "user.invalid-phone-number",
    UserInvalidPassword = "user.invalid-password",
    UserInvalidBirthDate = "user.invalid-birth-date",
    UserInvalidGender = "user.invalid-gender",
    UserInvalidRole = "user.invalid-role",
    UserInvalidPreferences = "user.invalid-preferences",
    UserInvalidLocation = "user.invalid-location",
    UserInvalidFile = "user.invalid-file",
    UserFileTooLarge = "user.file-too-large",
    UserUnsupportedFileType = "user.unsupported-file-type",
    OrganizationNotFound = "organization.not-found",
    OrganizationInvalidSlug = "organization.invalid-slug",
    OrganizationInvalidName = "organization.invalid-name",
    OrganizationInvalidDescription = "organization.invalid-description",
    OrganizationInvalidLocation = "organization.invalid-location",
    OrganizationInvalidSocialLink = "organization.invalid-social-link",
    OrganizationAlreadyExists = "organization.already-exists",
    OrganizationUnauthorized = "organization.unauthorized",
    OrganizationMemberNotFound = "organization.member-not-found",
    OrganizationMemberInvalidRole = "organization.member-invalid-role",
    OrganizationMemberAlreadyExists = "organization.member-already-exists",
    EventNotFound = "event.not-found",
    EventInvalidTitle = "event.invalid-title",
    EventInvalidDescription = "event.invalid-description",
    EventInvalidLocation = "event.invalid-location",
    EventInvalidDates = "event.invalid-dates",
    EventInvalidTickets = "event.invalid-tickets",
    EventInvalidStyles = "event.invalid-styles",
    EventInvalidType = "event.invalid-type",
    EventInvalidVisibility = "event.invalid-visibility",
    EventUnavailable = "event.unavailable",
    EventTicketNotFound = "event.ticket-not-found",
    EventTicketUnavailable = "event.ticket-unavailable",
    EventTicketInvalidQuantity = "event.ticket-invalid-quantity",
    OrderNotFound = "order.not-found",
    OrderInvalidStatus = "order.invalid-status",
    OrderInvalidPayment = "order.invalid-payment",
    OrderPaymentFailed = "order.payment-failed",
    OrderAlreadyPaid = "order.already-paid",
    OrderCancelled = "order.cancelled",
    OrderRefunded = "order.refunded",
    OrderExpired = "order.expired",
    BookingNotFound = "booking.not-found",
    BookingInvalidStatus = "booking.invalid-status",
    BookingInvalidTickets = "booking.invalid-tickets",
    BookingTicketNotFound = "booking.ticket-not-found",
    BookingTicketInvalidToken = "booking.ticket-invalid-token",
    BookingTicketExpired = "booking.ticket-expired",
    BookingTicketUsed = "booking.ticket-used",
    FileNotFound = "file.not-found",
    FileInvalidType = "file.invalid-type",
    FileTooLarge = "file.too-large",
    FileUploadFailed = "file.upload-failed",
    ValidationError = "validation.error",
    DatabaseError = "database.error",
    InternalServerError = "server.internal-error",
    NotFound = "not-found",
    BadRequest = "bad-request",
    Unauthorized = "unauthorized",
    Forbidden = "forbidden",
    TooManyRequests = "too-many-requests",
    ServiceUnavailable = "service-unavailable",
    TooManyRequestsAuth = "rate-limit.auth",
    TooManyRequestsApi = "rate-limit.api",
    WebhookInvalidSignature = "webhook.invalid-signature",
    WebhookInvalidEvent = "webhook.invalid-event",
    WebhookProcessingFailed = "webhook.processing-failed",
    PaymentRequired = "payment.required",
    PaymentMethodRequired = "payment.method-required",
    PaymentFailed = "payment.failed",
    PaymentCancelled = "payment.cancelled",
    PaymentRefunded = "payment.refunded",
    BillingInvalidAccount = "billing.invalid-account",
    BillingAccountRequired = "billing.account-required",
    NotificationInvalidType = "notification.invalid-type",
    NotificationSendingFailed = "notification.sending-failed",
    CacheError = "cache.error",
    CacheMiss = "cache.miss",
    ExternalServiceError = "external-service.error",
    ExternalServiceTimeout = "external-service.timeout",
    ExternalServiceUnavailable = "external-service.unavailable"
}

declare enum FeedType {
    Following = "following",
    Discover = "discover"
}
type FeedPost = UserPost | OrganizationEvent[];
type FeedEndpoints = Endpoint<"GET", "/feed/following", ArrayResult<FeedPost>, ArrayOptions<FeedPost>> | Endpoint<"GET", "/feed/discover", ArrayResult<FeedPost>, ArrayOptions<FeedPost>>;

interface Health<T extends string = string> extends HealthCheckResult {
    info?: Record<T, HealthIndicatorResult[T]>;
    error?: Record<T, HealthIndicatorResult[T]>;
    details: Record<T, HealthIndicatorResult[T]>;
}
type MemorySnapshot = {
    heapUsed: number;
    heapTotal: number;
    rss: number;
    external: number;
};
type HealthMemory = {
    before: MemorySnapshot;
    afterGc: MemorySnapshot;
};
type HealthEndpoints = Endpoint<"GET", "/health", Health<"database" | "app" | "api" | "database">> | Endpoint<"GET", "/health/database", Health<"database">> | Endpoint<"GET", "/health/api", Health<"api">> | Endpoint<"GET", "/health/app", Health<"app">> | Endpoint<"GET", "/health/memory", HealthMemory>;

/**
 * Represents a GeoJSON point with specific geographic coordinates.
 *
 * @see https://geojson.org/geojson-spec.html#point
 *
 * @property {"Point"} type - The type of the geometry, which is always "Point" for a GeoJSON point.
 * @property {[number, number]} coordinates - The coordinates of the point, represented as [longitude, latitude].
 */
type GeoPoint = {
    type: "Point";
    coordinates: [number, number];
};
type Location$1 = {
    name?: string;
    address: string;
    zipCode: string;
    city: string;
    country: string;
    geometry: GeoPoint;
};
type GeoSearchAggregation<T> = {
    metadata: {
        total: number;
    }[];
    data: T[];
};
type Distance<T> = T & {
    distance: number;
};

type NotificationEndpoints = Endpoint<"POST", "/notifications/subscribe/beta", null, {
    email: string;
}>;

type OrganizationEventOrderEndpoints = Endpoint<"POST", "/organizations/@:organizationSlug/events/:eventSlug/orders", Order, CreateOrganizationEventOrderDto>;

declare class CreateOrganizationEventStyleDto {
    type: OrganizationEventStyleType;
    emoji: string;
    name: string;
}

declare class UpdateOrganizationEventStyleDto extends CreateOrganizationEventStyleDto {
}

type OrganizationEventStyle = Base & {
    type: OrganizationEventStyleType;
    emoji: string;
    name: string;
    slug: string;
};
declare enum OrganizationEventStyleType {
    Music = "music",
    Dress = "dress",
    Sport = "sport",
    Food = "food",
    Art = "art"
}
type OrganizationEventStyleEndpoints = Endpoint<"GET", "/organizations/events/styles", ArrayResult<OrganizationEventStyle>, ArrayOptions<OrganizationEventStyle>> | Endpoint<"GET", "/organizations/events/styles/:styleSlug", OrganizationEventStyle> | Endpoint<"POST", "/organizations/events/styles", OrganizationEventStyle, CreateOrganizationEventStyleDto> | Endpoint<"PUT", "/organizations/events/styles/:styleSlug", OrganizationEventStyle, UpdateOrganizationEventStyleDto> | Endpoint<"DELETE", "/organizations/events/styles/:styleSlug", OrganizationEventStyle>;

type OrganizationEventViewOptions = {
    events: string | string[];
};
type OrganizationEventViewResult = {
    eventId: string;
    visitsCount: number;
};
type OrganizationEventViewEndpoints = Endpoint<"POST", "/organizations/@:organizationSlug/events/:eventSlug/views", boolean, null> | Endpoint<"GET", "/organizations/events/views/stream", ReadableStream<OrganizationEventViewResult>, OrganizationEventViewOptions>;

type OrganizationEventTicket = Base & {
    name: string;
    description?: string;
    price: Stripe__default.Price;
    product: Stripe__default.Product;
    fee: number;
    quantity: number;
    type: OrganizationEventTicketType;
    category: OrganizationEventTicketCategory;
    externalId?: string;
    isVisible: boolean;
    isFeesIncluded: boolean;
    startAt?: Date;
    endAt?: Date;
    event: OrganizationEvent;
};
declare enum OrganizationEventTicketType {
    ETicket = "e-ticket",
    Other = "other"
}
declare enum OrganizationEventTicketCategory {
    Entry = "entry",
    Package = "package",
    Meal = "meal",
    Drink = "drink",
    Parking = "parking",
    Accommodation = "accommodation",
    Camping = "camping",
    Locker = "locker",
    Shuttle = "shuttle",
    Other = "other"
}
type OrganizationEventTicketEndpoints = Endpoint<"GET", "/organizations/@:organizationSlug/events/:eventSlug/tickets", OrganizationEventTicket[]> | Endpoint<"GET", "/organizations/@:organizationSlug/events/:eventSlug/tickets/:ticketId", OrganizationEventTicket> | Endpoint<"POST", "/organizations/@:organizationSlug/events/:eventSlug/tickets", OrganizationEventTicket, CreateOrganizationEventTicketDto> | Endpoint<"PUT", "/organizations/@:organizationSlug/events/:eventSlug/tickets/:ticketId", OrganizationEventTicket, UpdateOrganizationEventTicketDto> | Endpoint<"DELETE", "/organizations/@:organizationSlug/events/:eventSlug/tickets/:ticketId", OrganizationEventTicket[], null>;

type OrganizationEvent = Base & {
    title: string;
    description: string;
    slug: string;
    organization: OrganizationProfile;
    type: OrganizationEventType;
    visibility: OrganizationEventVisibilityType;
    currency: Currency;
    flyers: string[];
    trailers: string[];
    location: Location$1;
    tickets: OrganizationEventTicket[];
    styles: OrganizationEventStyle[];
    artists: EventArtistRef[];
    status: OrganizationEventStatus;
    viewsCount: number;
    visitsCount: number;
    visitorsCount: number;
    bouncesCount: number;
    totalDurationSeconds: number;
    averageViewsPerVisitorCount: number;
    bounceRate: number;
    averageVisitDurationSeconds: number;
    hypeCount: number;
    minPrice: number;
    startAt: Date;
    endAt: Date;
};
declare enum OrganizationEventType {
    Clubbing = "clubbing",
    Concert = "concert",
    Festival = "festival",
    HouseParty = "house_party",
    FriendsParty = "friends_party",
    Afterwork = "afterwork",
    DancingLunch = "dancing_lunch",
    Diner = "diner",
    Garden = "garden",
    AfterBeach = "after_beach",
    Spectacle = "spectacle",
    Cruise = "cruise",
    OutsideAnimation = "outside_animation",
    Sport = "sport",
    Match = "match",
    Seminar = "seminar",
    Conference = "conference",
    WellnessDay = "wellness_day",
    Workshop = "workshop",
    TradeFair = "trade_fair",
    ConsumerShow = "consumer_show",
    Membership = "membership"
}
declare enum OrganizationEventVisibilityType {
    Public = "public",
    Unlisted = "unlisted",
    Private = "private"
}
declare enum OrganizationEventFileType {
    Flyer = "flyer",
    Trailer = "trailer"
}
declare enum OrganizationEventStatus {
    Upcoming = "upcoming",
    Ongoing = "ongoing",
    Ended = "ended"
}
type ExternalOffer = {
    name: string;
    description?: string;
    price: number;
    available: boolean;
};
type ExternalContact = {
    type: "phone" | "email" | "website";
    value: string;
};
type ExternalSource = {
    organizerName: string;
    contacts: ExternalContact[];
    offers: ExternalOffer[];
};
type OrganizationEventRequestResponse = {
    contacts: ExternalContact[];
};
type OrganizationEventNearbyOptions = ArrayOptions<OrganizationEvent> & {
    latitude: number;
    longitude: number;
    radius?: number;
};
type OrganizationEventArrayOptions = ArrayOptions<OrganizationEvent> & {
    status?: OrganizationEventStatus | OrganizationEventStatus[];
    types?: OrganizationEventType | OrganizationEventType[];
    styles?: string | string[];
    city?: string;
    country?: string;
};
type SearchOrganizationEventsOptions = ArrayOptions<OrganizationEvent> & {
    q: string;
};
type OrganizationEventCalendar = {
    [date: string]: OrganizationEvent[];
};
type OrganizationEventEndpoints = Endpoint<"GET", "/organizations/events/search", ArrayResult<OrganizationEvent>, SearchOrganizationEventsOptions> | Endpoint<"GET", "/organizations/events/calendar/:year/:month", OrganizationEventCalendar> | Endpoint<"GET", "/organizations/events", ArrayResult<OrganizationEvent>, OrganizationEventArrayOptions> | Endpoint<"GET", "/organizations/events/suggestions", ArrayResult<OrganizationEvent>, ArrayOptions<OrganizationEvent>> | Endpoint<"GET", "/organizations/events/nearby", ArrayResult<OrganizationEvent>, OrganizationEventNearbyOptions> | Endpoint<"GET", "/organizations/@:organizationSlug/events", ArrayResult<OrganizationEvent>, OrganizationEventArrayOptions> | Endpoint<"GET", "/organizations/@:organizationSlug/events/:eventSlug", OrganizationEvent> | Endpoint<"POST", "/organizations/@:organizationSlug/events", OrganizationEvent, CreateOrganizationEventDto> | Endpoint<"PUT", "/organizations/@:organizationSlug/events/:eventSlug", OrganizationEvent, UpdateOrganizationEventDto> | Endpoint<"DELETE", "/organizations/@:organizationSlug/events/:eventSlug", OrganizationEvent, null> | Endpoint<"POST", "/organizations/@:organizationSlug/events/:eventSlug/files/:eventFileType", string, FormData> | Endpoint<"POST", "/events/files/:eventFileType", string, FormData> | Endpoint<"POST", "/organizations/@:organizationSlug/events/:eventSlug/request", OrganizationEventRequestResponse> | OrganizationEventOrderEndpoints | OrganizationEventPromoCodeEndpoints | OrganizationEventStyleEndpoints | OrganizationEventTicketEndpoints | OrganizationEventViewEndpoints;

type OrganizationAnalyticsOverview = {
    metrics: {
        totalRevenue: {
            current: number;
            previous: number;
            percentageChange: number;
        };
        totalOrders: {
            current: number;
            previous: number;
            percentageChange: number;
        };
        totalTicketsSold: {
            current: number;
            previous: number;
            percentageChange: number;
        };
        activeEvents: number;
    };
    chartData: {
        date: string;
        revenues: number;
        orders: number;
        ticketsSold: number;
        events: number;
    }[];
};
type OrganizationEventAnalytics = {
    event: OrganizationEvent;
    metrics: {
        views: number;
        visits: number;
        visitors: number;
        totalRevenue: number;
        totalOrders: number;
        totalTicketsSold: number;
    };
};
type AnalyticsOptions = {
    period?: "7d" | "30d" | "90d" | "12m";
    startDate?: string;
    endDate?: string;
};
type EventAnalyticsOptions = AnalyticsOptions & {
    status?: "upcoming" | "past" | "all";
};
type OrganizationAnalyticsEndpoints = Endpoint<"GET", "/organizations/@:organizationSlug/analytics/overview", OrganizationAnalyticsOverview, AnalyticsOptions> | Endpoint<"GET", "/organizations/@:organizationSlug/analytics/events", ArrayResult<OrganizationEventAnalytics>, ArrayOptions<OrganizationEventAnalytics> & EventAnalyticsOptions>;

type OrganizationCustomer = UserProfile & {
    email?: string;
    phoneNumber?: string;
    firstName: string;
    lastName: string;
    fullName: string;
    birthDate: Date;
    metadata: OrganizationCustomerMetadata;
};
type OrganizationCustomerMetadata = UserProfileMetadata & {
    bookingsCount: number;
    eventsAttendedCount: number;
    totalSpent: number;
    lastBookingAt?: Date;
};
type OrganizationCustomersEndpoints = Endpoint<"GET", "/organizations/@:organizationSlug/customers", ArrayResult<OrganizationCustomer>, ArrayOptions<OrganizationCustomer>> | Endpoint<"GET", "/organizations/@:organizationSlug/customers/:username", OrganizationCustomer>;

declare enum OrganizationNotificationType {
    OrganizationCreated = "organization_created",
    Follow = "follow",
    MemberInvited = "member_invited",
    MemberJoined = "member_joined",
    MemberLeft = "member_left",
    MemberRoleUpdated = "member_role_updated",
    EventCreated = "event_created",
    EventUpdated = "event_updated",
    OrderReceived = "order_received",
    PayoutCompleted = "payout_completed",
    EventMilestone = "event_milestone",
    BillingAccountConnected = "billing_account_connected"
}
type OrganizationNotificationBase = Base & {
    type: OrganizationNotificationType;
    isSeen: boolean;
    message?: string;
    metadata?: Record<string, unknown>;
};
type OrganizationNotificationWithActor = OrganizationNotificationBase & {
    actor?: UserProfile;
};
type OrganizationNotification = OrganizationNotificationWithActor;
type OrganizationNotificationEndpoints = Endpoint<"GET", "/organizations/@:organizationSlug/notifications", ArrayResult<OrganizationNotification>, ArrayOptions<OrganizationNotification>> | Endpoint<"GET", "/organizations/@:organizationSlug/notifications/count", number, {
    unseen?: boolean;
}> | Endpoint<"PUT", "/organizations/@:organizationSlug/notifications/read", void, undefined>;

type OrganizationOrder = Omit<Order, "user"> & {
    customer: OrganizationCustomer;
};
type OrganizationOrdersEndpoints = Endpoint<"GET", "/organizations/@:organizationSlug/orders", ArrayResult<OrganizationOrder>, ArrayOptions<OrganizationOrder>> | Endpoint<"GET", "/organizations/@:organizationSlug/orders/:orderId", OrganizationOrder> | Endpoint<"GET", "/organizations/@:organizationSlug/events/:eventSlug/orders", ArrayResult<OrganizationOrder>, ArrayOptions<OrganizationOrder>> | Endpoint<"GET", "/organizations/@:organizationSlug/events/:eventSlug/bookings", ArrayResult<UserBooking>, ArrayOptions<UserBooking>> | Endpoint<"GET", "/organizations/@:organizationSlug/events/:eventSlug/participants", ArrayResult<OrganizationCustomer>, ArrayOptions<OrganizationCustomer>> | Endpoint<"GET", "/organizations/@:organizationSlug/events/:eventSlug/orders/export", string> | Endpoint<"GET", "/organizations/@:organizationSlug/events/:eventSlug/bookings/export", string> | Endpoint<"GET", "/organizations/@:organizationSlug/events/:eventSlug/participants/export", string>;

type OrganizationToken = Omit<Base, "updatedAt"> & {
    type: OrganizationTokenType;
    value: string;
    expiresAt: Date;
    organization?: Organization;
    role?: OrganizationMemberRole;
};
declare enum OrganizationTokenType {
    InvitationLink = "invitation_link"
}

type Organization = Base & {
    slug: string;
    identity: OrganizationIdentity;
    members: OrganizationMember[];
    location?: Location$1;
    events: OrganizationEvent[];
    savedTickets: OrganizationEventTicket[];
    verified: boolean;
    billing: OrganizationBilling;
};
type OrganizationBilling = {
    account: string;
    vatRate: number;
};
type OrganizationBillingAccount = Stripe__default.Account;
declare enum OrganizationPayoutStatus {
    Paid = "paid",
    Pending = "pending",
    InTransit = "in_transit",
    Failed = "failed",
    Canceled = "canceled"
}
type OrganizationBillingBalance = {
    balance: {
        amount: number;
        currency: Currency;
    }[];
    pending: {
        amount: number;
        currency: Currency;
    }[];
    payouts: {
        id: string;
        amount: number;
        currency: Currency;
        status: OrganizationPayoutStatus;
        arrival_date: number;
    }[];
};
type OrganizationBillingPendingRevenue = {
    amount: number;
    count: number;
    currency: Currency;
}[];
type OrganizationIdentity = OrganizationProfile;
declare enum OrganizationFileType {
    Avatar = "avatar",
    Banner = "banner"
}
type OrganizationEndpoints = Endpoint<"GET", "/organizations/search", Organization[], {
    q: string;
    limit?: number;
}> | Endpoint<"GET", "/organizations", ArrayResult<Organization>, ArrayOptions<Organization>> | Endpoint<"GET", "/organizations/@:organizationSlug", Organization> | Endpoint<"POST", "/organizations", Organization, CreateOrganizationDto> | Endpoint<"PUT", "/organizations/@:organizationSlug", Organization, UpdateOrganizationDto> | Endpoint<"DELETE", "/organizations/@:organizationSlug", Organization, undefined> | Endpoint<"POST", "/organizations/@:organizationSlug/files/:organizationFileType", string, FormData> | Endpoint<"GET", "/organizations/@:organizationSlug/billing/account", OrganizationBillingAccount> | Endpoint<"GET", "/organizations/@:organizationSlug/billing/link", void> | Endpoint<"GET", "/organizations/@:organizationSlug/billing/balance", OrganizationBillingBalance> | Endpoint<"GET", "/organizations/@:organizationSlug/billing/pending", OrganizationBillingPendingRevenue> | Endpoint<"GET", "/organizations/@:organizationSlug/billing/dashboard", void> | OrganizationEventEndpoints | OrganizationMembersEndpoints | OrganizationAnalyticsEndpoints | OrganizationCustomersEndpoints | OrganizationNotificationEndpoints | OrganizationOrdersEndpoints;

type PlaceCountry = Base & {
    geonameId: number;
    name: string;
    code: string;
    isoAlpha3: string;
    slug: string;
    continent: