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: string;
    continentName: string;
    capital: string;
    population: number;
    areaInSqKm: number;
    languages: string;
    currencyCode: string;
    north: number;
    south: number;
    east: number;
    west: number;
};
type PlaceCity = Base & {
    geonameId: number;
    name: string;
    asciiName: string;
    country: string;
    countryCode: string;
    region: string;
    department: string;
    latitude: number;
    longitude: number;
    population: number;
    timezone: string;
    isCapital: boolean;
    citySlug: string;
    countrySlug: string;
};
type ListPlaceCountriesOptions = ArrayOptions<PlaceCountry> & {
    code?: string;
};
type SearchPlacesOptions = ArrayOptions<PlaceCity> & {
    q: string;
    countryCode?: string;
};
type NearbyCitiesOptions = ArrayOptions<PlaceCity> & {
    radius?: number;
};
type PlaceEndpoints = Endpoint<"GET", "/places/countries", ArrayResult<PlaceCountry>, ListPlaceCountriesOptions> | Endpoint<"GET", "/places/countries/:countrySlug", PlaceCountry> | Endpoint<"GET", "/places/countries/:countrySlug/cities", ArrayResult<PlaceCity>, ArrayOptions<PlaceCity>> | Endpoint<"GET", "/places/countries/:countrySlug/cities/:citySlug", PlaceCity | ExcludeBase<PlaceCity>> | Endpoint<"GET", "/places/countries/:countrySlug/cities/:citySlug/nearby", ArrayResult<Distance<PlaceCity>>, NearbyCitiesOptions> | Endpoint<"GET", "/places/cities", ArrayResult<PlaceCity>, ArrayOptions<PlaceCity>> | Endpoint<"GET", "/places/cities/search", ArrayResult<PlaceCity>, SearchPlacesOptions>;

type ProxyMediaOptions = {
    token: string;
};
type ProxyMediaResponse = ArrayBuffer;
type ProxyEndpoints = Endpoint<"GET", "/proxy/media", ProxyMediaResponse, ProxyMediaOptions>;

declare const ROADMAP_REACTIONS: readonly ["👍", "❤️", "🎉", "👀", "🚀"];
type RoadmapReaction = (typeof ROADMAP_REACTIONS)[number];
type RoadmapReactionCounts = {
    [K in RoadmapReaction]?: number;
};
declare enum RoadmapFeatureStatus {
    ComingSoon = "coming-soon",
    Shipped = "shipped"
}
type RoadmapFeature = {
    id: string;
    title: string;
    description: string;
    status: RoadmapFeatureStatus;
    date?: string;
};
type AddRoadmapReactionBody = {
    reaction: RoadmapReaction;
};
type RoadmapEndpoints = Endpoint<"GET", "/roadmap/reactions/:featureId", RoadmapReactionCounts, {
    featureId: string;
}> | Endpoint<"GET", "/roadmap/reactions/stream/:featureId", void, {
    featureId: string;
}> | Endpoint<"POST", "/roadmap/reactions/:featureId", RoadmapReactionCounts, AddRoadmapReactionBody>;

type SitemapCounts = {
    limit: number;
    profiles: number;
    events: number;
    countries: number;
    cities: number;
    types: number;
    styles: number;
    careers: number;
};
type SitemapEndpoints = Endpoint<"GET", "/sitemaps/counts", SitemapCounts>;

type WeatherForecast = {
    date: string;
    tempMin: number;
    tempMax: number;
    conditionText: string;
    conditionIcon: string;
    conditionCode: number;
    chanceOfRain: number;
    windKph: number;
};
type WeatherEndpoints = Endpoint<"GET", "/weather/forecast", WeatherForecast | null>;

type WebhookEndpoints = Endpoint<"POST", "/webhooks/stripe", boolean, Stripe__default.Event>;

type Base = {
    id: string;
    createdAt: Date;
    updatedAt: Date;
};
type ExcludeBase<T> = Omit<T, keyof Base>;
type DeepPartial<T> = {
    [P in keyof T]?: T[P] extends object ? DeepPartial<T[P]> : T[P];
};
declare enum Language {
    FR = "fr",
    EN = "en"
}
type ArraySortOptions = {
    /**
     * Field to sort
     */
    field: string;
    /**
     * Order to sort
     */
    order: "asc" | "desc";
};
type ArrayPaginationOptions = {
    /**
     * Page number
     */
    page?: number;
    /**
     * Number of items per page
     */
    limit?: number;
    /**
     * Offset to start from
     */
    offset?: number;
};
type ArrayFilterOptions = {
    /**
     * Field to filter
     */
    field: string;
    /**
     * Value to filter
     */
    value: string;
    /**
     * Operator to use
     */
    operator: "eq" | "ne" | "gt" | "lt" | "gte" | "lte" | "in" | "nin";
};
type ArrayOptions<_T> = {
    /**
     * Select only specific fields to return (e.g. ["slug", "organization.slug", "updatedAt"])
     * When provided, only the specified fields will be included in the response.
     * Supports dot notation for nested relations (e.g. "organization.slug").
     */
    select?: string[];
    /**
     * Sort results by field and direction.
     * Format: "field:asc" or "field:desc"
     * Supports multiple sort criteria: ["field1:asc", "field2:desc"]
     *
     * @example
     * sort: "startAt:asc"
     * sort: ["viewsCount:desc", "createdAt:desc"]
     */
    sort?: string | string[];
} & ArrayPaginationOptions;
type ArrayResult<T> = {
    items: T[];
    total: number;
    page: number;
    limit: number;
};

type Endpoint<M extends Options["method"], Path extends string, Res, Body = undefined> = {
    method: M;
    path: Path;
    res: Res;
    body: Body;
};
type SSEEndpoints = Extract<Endpoints, {
    method: "GET";
}> extends infer E ? E extends {
    res: ReadableStream<infer _>;
    path: infer P;
} ? P : never : never;
type Endpoints = ApiKeyEndpoints | ArtistEndpoints | AuthEndpoints | CareerEndpoints | ChannelEndpoints | ChannelMessageEndpoints | CurrenciesEndpoints | FeedEndpoints | HealthEndpoints | OrderEndpoints | OrganizationEndpoints | PlaceEndpoints | ProfileEndpoints | ProxyEndpoints | RoadmapEndpoints | SitemapEndpoints | UserEndpoints | WeatherEndpoints | WebhookEndpoints | NotificationEndpoints;

declare enum ApiKeyTier {
    PUBLIC = "public",
    INTERNAL = "internal"
}
declare enum ApiKeyType {
    User = "user",
    App = "app"
}
type ApiKey = Base & {
    key: string;
    name: string;
    type: ApiKeyType;
    tier: ApiKeyTier;
    rateLimit: number;
    allowedOrigins: string[];
    user: UserProfile;
    lastUsedAt?: Date;
    isActive: boolean;
};
type ApiKeyEndpoints = Endpoint<"GET", "/api-keys", ArrayResult<ApiKey>> | Endpoint<"GET", "/api-keys/:apiKeyId", ApiKey> | Endpoint<"POST", "/api-keys", ApiKey, CreateApiKeyDto> | Endpoint<"PUT", "/api-keys/:apiKeyId", ApiKey, UpdateApiKeyDto> | Endpoint<"DELETE", "/api-keys/:apiKeyId", ApiKey, undefined>;

declare class CreateApiKeyDto {
    name: string;
    type?: ApiKeyType;
    tier?: ApiKeyTier;
    allowedOrigins?: string[];
}

declare class UpdateApiKeyDto {
    name?: string;
    isActive?: boolean;
    type?: ApiKeyType;
    tier?: ApiKeyTier;
    allowedOrigins?: string[];
}

declare class AddParticipantDto {
    username: string;
}

declare class CreateChannelDto {
    type: ChannelType;
    participantUsernames: string[];
    name?: string;
}

declare class AddReactionDto {
    emoji: string;
}

declare class ContentOrAttachmentsConstraint implements ValidatorConstraintInterface {
    validate(_value: unknown, args: ValidationArguments): boolean;
    defaultMessage(_args: ValidationArguments): string;
}
declare class CreateChannelMessageDto {
    content?: string;
    attachments?: string[];
    replyToId?: string;
}

declare class ReportChannelMessageDto {
    reason: ChannelMessageReportReason;
    description?: string;
}

declare class UpdateChannelMessageDto {
    content?: string;
}

declare class UpdateChannelDto {
    name?: string;
}

declare class GeoPointDto implements GeoPoint {
    type: "Point";
    coordinates: [number, number];
    constructor();
}
declare class CreateLocationDto implements Location$1 {
    name?: string;
    address: string;
    zipCode: string;
    city: string;
    country: string;
    geometry: GeoPointDto;
}

/**
 * Strips trailing segments from `address` that are already represented by
 * structured fields (`zipCode`, `city`, `country`).
 *
 * Mapbox Search Box returns `feature.properties.context.address.name` as the
 * full formatted address (e.g. `"Place de l'Odéon, 75006 Paris, France"`)
 * for POIs that don't have a strict street number, which leads to duplicated
 * data when concatenated client-side. This normalizer guarantees the stored
 * `address` only contains the street-level information, regardless of how
 * the client built it.
 */
declare const normalizeAddress: (address: string | undefined, parts: {
    zipCode?: string;
    city?: string;
    country?: string;
}) => string | undefined;

declare class UpdateLocationDto implements Partial<Location$1> {
    name?: string;
    address?: string;
    zipCode?: string;
    city?: string;
    country?: string;
    geometry?: GeoPointDto;
}

declare class CreateOrganizationMemberDto {
    user: string;
    role: OrganizationMemberRole;
}

declare class CreateOrganizationDto {
    organizationSlug?: string;
    identity: CreateOrganizationIdentityDto;
    members: CreateOrganizationMemberDto[];
    location?: Location$1;
}
declare class CreateOrganizationIdentityDto {
    displayName: string;
    description?: string;
    avatarUrl?: string;
    bannerUrl?: string;
    links?: string[];
}

declare class EventArtistDto implements EventArtistRef {
    id: string;
    permalink: string;
    username: string;
}

type CreateOrganizationEventTicketInput = Omit<ExcludeBase<OrganizationEventTicket>, "price" | "product" | "event" | "fee"> & {
    price: number;
};
declare class CreateOrganizationEventTicketDto implements CreateOrganizationEventTicketInput {
    name: string;
    description?: string;
    price: number;
    quantity: number;
    type: OrganizationEventTicketType;
    category: OrganizationEventTicketCategory;
    isVisible: boolean;
    isFeesIncluded: boolean;
    startAt?: Date;
    endAt?: Date;
}

declare class UpdateOrganizationEventTicketDto implements DeepPartial<CreateOrganizationEventTicketInput> {
    id?: string;
    name?: string;
    description?: string;
    price?: number;
    quantity?: number;
    type?: OrganizationEventTicketType;
    category?: OrganizationEventTicketCategory;
    isVisible?: boolean;
    isFeesIncluded?: boolean;
    startAt?: Date;
    endAt?: Date;
}

declare class AtLeastOneMediaConstraint implements ValidatorConstraintInterface {
    validate(_value: unknown, args: ValidationArguments): boolean;
    defaultMessage(): string;
}
declare function AtLeastOneMedia(validationOptions?: ValidationOptions): (object: object, propertyName: string) => void;
type CreateOrganizationEventInput = Omit<ExcludeBase<OrganizationEvent>, "slug" | "styles" | "tickets" | "artists" | "organization" | "status" | "viewsCount" | "visitsCount" | "visitorsCount" | "bouncesCount" | "totalDurationSeconds" | "averageViewsPerVisitorCount" | "bounceRate" | "averageVisitDurationSeconds" | "hypeCount" | "minPrice"> & {
    slug?: string;
    styles: string[];
    tickets: CreateOrganizationEventTicketInput[];
    artists?: EventArtistDto[];
};
declare class BaseOrganizationEventDto {
    title: string;
    slug?: string;
    description: string;
    type: OrganizationEventType;
    visibility: OrganizationEventVisibilityType;
    currency: Currency;
    flyers: string[];
    trailers: string[];
    location: CreateLocationDto;
    styles: string[];
    artists?: EventArtistDto[];
    startAt: Date;
    endAt: Date;
}
declare class CreateOrganizationEventDto extends BaseOrganizationEventDto implements CreateOrganizationEventInput {
    tickets: CreateOrganizationEventTicketDto[];
}

declare class CreateOrganizationEventOrderDto {
    cart: string[];
    promoCode?: string;
}

declare class CreateOrganizationEventPromoCodeDto {
    code: string;
    type: OrganizationEventPromoCodeType;
    value: number;
    maxUses?: number;
    isActive?: boolean;
    minCartAmount?: number;
    expiresAt?: Date;
    ticketIds?: string[];
}

declare class UpdateOrganizationEventPromoCodeDto {
    code?: string;
    type?: OrganizationEventPromoCodeType;
    value?: number;
    maxUses?: number;
    isActive?: boolean;
    minCartAmount?: number;
    expiresAt?: Date;
    ticketIds?: string[];
}

declare class AtLeastOneMediaOnUpdateConstraint implements ValidatorConstraintInterface {
    validate(_value: unknown, args: ValidationArguments): boolean;
    defaultMessage(): string;
}
declare function AtLeastOneMediaOnUpdate(validationOptions?: ValidationOptions): (object: object, propertyName: string) => void;
declare class UpdateOrganizationEventDto implements DeepPartial<CreateOrganizationEventInput> {
    title?: string;
    slug?: string;
    description?: string;
    type?: OrganizationEventType;
    visibility?: OrganizationEventVisibilityType;
    flyers?: string[];
    trailers?: string[];
    location?: UpdateLocationDto;
    tickets?: UpdateOrganizationEventTicketDto[];
    styles?: string[];
    artists?: EventArtistDto[];
    startAt?: Date;
    endAt?: Date;
}

declare class AcceptOrganizationMemberInvitationDto {
    token: string;
}

declare class CreateOrganizationMemberInvitationLinkDto {
    role?: OrganizationMemberRole;
}

declare class UpdateOrganizationMemberDto {
    role: OrganizationMemberRole;
}

declare class UpdateOrganizationDto {
    slug?: string;
    identity?: UpdateOrganizationIdentityDto;
    members?: UpdateOrganizationMemberDto[];
    location?: Location;
}
declare class UpdateOrganizationIdentityDto {
    displayName?: string;
    description?: string;
    avatarUrl?: string;
    bannerUrl?: string;
    links?: string[];
}

declare class CreateUserDto {
    identifier: CreateUserIdentifierDto;
    identity: CreateUserIdentityDto;
    password: string;
}
declare class CreateUserIdentifierDto implements Partial<Pick<UserIdentifier, "email" | "phoneNumber" | "username">> {
    email?: string;
    phoneNumber?: string;
    username: string;
}
declare class CreateUserIdentityDto {
    firstName: string;
    lastName: string;
    gender: UserIdentityGender;
    avatarUrl?: string;
    birthDate: Date;
    links?: string[];
}

declare class GoogleOneTapDto {
    credential: string;
}

declare class RecoveryDto {
    identifier: string;
}

declare class RecoveryResetDto {
    tokenId: string;
    tokenValue: string;
    password: string;
}

declare class SignInUserDto {
    identifier: string;
    password: string;
}

declare class UpdateUserDto {
    identifier?: UpdateUserIdentifierDto;
    identity?: UpdateUserIdentityDto;
    password?: string;
}
declare class UpdateUserIdentifierDto implements Partial<Pick<UserIdentifier, "email" | "phoneNumber" | "username">> {
    email?: string;
    phoneNumber?: string;
    username?: string;
}
declare class UpdateUserIdentityDto implements Partial<Pick<UserIdentity, "firstName" | "lastName" | "displayName" | "description" | "avatarUrl" | "bannerUrl" | "gender" | "birthDate">> {
    firstName?: string;
    lastName?: string;
    displayName?: string;
    description?: string;
    avatarUrl?: string | undefined;
    bannerUrl?: string | undefined;
    gender?: UserIdentityGender;
    birthDate?: Date;
    links?: string[];
}

declare class VerifyEmailConfirmDto {
    tokenId: string;
    tokenValue: string;
}

type OrganizationMember = Base & {
    organization: OrganizationProfile;
    role: OrganizationMemberRole;
    status: OrganizationMemberStatus;
    user?: UserProfile;
    token?: UserToken;
};
declare enum OrganizationMemberStatus {
    Pending = "pending",
    Accepted = "accepted",
    Rejected = "rejected"
}
declare enum OrganizationMemberRole {
    Owner = "owner",
    Admin = "admin",
    Manager = "manager",
    Member = "member"
}
type OrganizationMembersEndpoints = Endpoint<"GET", "/organizations/members/~me", ArrayResult<OrganizationMember>, ArrayOptions<OrganizationMember>> | Endpoint<"GET", "/organizations/@:organizationSlug/members", ArrayResult<OrganizationMember>, ArrayOptions<OrganizationMember>> | Endpoint<"POST", "/organizations/@:organizationSlug/members", OrganizationMember, CreateOrganizationMemberDto> | Endpoint<"PUT", "/organizations/@:organizationSlug/members/:username", OrganizationMember, UpdateOrganizationMemberDto> | Endpoint<"DELETE", "/organizations/@:organizationSlug/members/:username", OrganizationMember[], undefined> | Endpoint<"GET", "/organizations/@:organizationSlug/members/invitations/links", ArrayResult<OrganizationToken>, ArrayOptions<OrganizationToken>> | Endpoint<"POST", "/organizations/@:organizationSlug/members/invitations/links", OrganizationToken, CreateOrganizationMemberInvitationLinkDto> | Endpoint<"POST", "/organizations/@:organizationSlug/members/invitations/accept", OrganizationMember, AcceptOrganizationMemberInvitationDto> | Endpoint<"PUT", "/organizations/@:organizationSlug/members/~me/accept", OrganizationMember, undefined> | Endpoint<"DELETE", "/organizations/@:organizationSlug/members/~me/reject", null, undefined> | Endpoint<"DELETE", "/organizations/@:organizationSlug/members/~me", null, undefined>;

declare const OrganizationMemberRolePower: {
    [key in OrganizationMemberRole]: number;
};
declare const UserRolePower: {
    [key in UserRole]: number;
};

declare class MemoryCacheStore implements CacheStore {
    private readonly cache;
    private readonly maxSize;
    constructor(maxSize?: number);
    get(key: string): Promise<CacheEntry<unknown> | null>;
    set(key: string, entry: CacheEntry<unknown>): Promise<void>;
    delete(key: string): Promise<void>;
    clear(): Promise<void>;
    size(): Promise<number>;
    keys(): Promise<string[]>;
}

type CacheEntry<T> = {
    data: T;
    timestamp: number;
};
type CacheStore = {
    get(key: string): Promise<CacheEntry<unknown> | null>;
    set(key: string, entry: CacheEntry<unknown>): Promise<void>;
    delete(key: string): Promise<void>;
    clear(): Promise<void>;
    size(): Promise<number>;
    keys(): Promise<string[]>;
};

type CacheOptions = {
    enabled: boolean;
    ttl?: number;
    maxSize?: number;
    methods?: Options["method"][];
    store?: CacheStore;
};
declare class CacheManager {
    private readonly store;
    private readonly options;
    constructor(options: CacheOptions);
    private generateKey;
    private shouldCache;
    private isValid;
    get<T>(method: Options["method"], url: string): Promise<T | null>;
    set<T>(method: Options["method"], url: string, data: T): Promise<void>;
    clear(): Promise<void>;
    stats(): Promise<{
        size: number;
        keys: string[];
    }>;
}

interface APIRequestOptions extends Options {
    apiKey?: string;
    accessToken?: string;
}
declare const request: <T>(url: string, options?: APIRequestOptions) => Promise<Response$1<APIResponse<T>>>;

type SuccessfulAPIResponse<T> = {
    success: true;
    data: T;
};
type ErroredAPIResponse = {
    success: false;
    message: string;
    statusCode: number;
    errors?: {
        [key: string]: string[];
    };
};
type APIResponse<T> = SuccessfulAPIResponse<T> | ErroredAPIResponse;
type PromisedAPIResponse<T> = Promise<APIResponse<T>>;
type PathsFor<M extends Options["method"]> = Extract<Endpoints, {
    method: M;
}>["path"];
type ResponseFor<M extends Options["method"], P extends PathsFor<M>> = Extract<Endpoints, {
    method: M;
    path: P;
}>["res"];
type Response<M extends Options["method"], P extends PathsFor<M>> = APIResponse<Extract<Endpoints, {
    method: M;
    path: P;
}>["res"]>;
type PromisedResponse<M extends Options["method"], P extends PathsFor<M>> = PromisedAPIResponse<Extract<Endpoints, {
    method: M;
    path: P;
}>["res"]>;
type Body<M extends Options["method"], P extends PathsFor<M>> = Extract<Endpoints, {
    method: M;
    path: P;
}>["body"];
type StringifiedQueryValue = string | string[];
type StringifiedQuery<T> = {
    [K in keyof T]: StringifiedQueryValue;
};
type QueryParams<M extends Options["method"], P extends PathsFor<M>> = StringifiedQuery<Extract<Endpoints, {
    method: M;
    path: P;
}>["body"]>;
declare class TonightPassAPIError<T> extends Error {
    readonly response: Response$1<APIResponse<T>>;
    readonly data: ErroredAPIResponse;
    readonly status: number;
    constructor(response: Response$1<APIResponse<T>>, data: ErroredAPIResponse);
}
type ClientOptions = {
    readonly baseURL: string;
    readonly apiKey?: string;
    readonly accessToken?: string;
    readonly cache?: CacheOptions;
};
declare class Client {
    private apiKey?;
    private accessToken?;
    private cacheManager?;
    baseURL: string;
    readonly url: (path: string, params: Query<string>) => string;
    constructor(options: ClientOptions);
    setOptions(options: ClientOptions): void;
    setAccessToken(accessToken: string | undefined): void;
    clearCache(): Promise<void>;
    getCacheStats(): Promise<{
        size: number;
        keys: string[];
    } | undefined>;
    get<Path extends PathsFor<"GET">>(path: Path, query?: Query<Path>, options?: APIRequestOptions): Promise<ResponseFor<"GET", Path>>;
    post<Path extends PathsFor<"POST">>(path: Path, body: Body<"POST", Path>, query?: Query<Path>, options?: APIRequestOptions): Promise<ResponseFor<"POST", Path>>;
    put<Path extends PathsFor<"PUT">>(path: Path, body: Body<"PUT", Path>, query?: Query<Path>, options?: APIRequestOptions): Promise<ResponseFor<"PUT", Path>>;
    patch<Path extends PathsFor<"PATCH">>(path: Path, body: Body<"PATCH", Path>, query?: Query<Path>, options?: APIRequestOptions): Promise<never>;
    delete<Path extends PathsFor<"DELETE">>(path: Path, body: Body<"DELETE", Path>, query?: Query<Path>, options?: APIRequestOptions): Promise<ResponseFor<"DELETE", Path>>;
    private requester;
}

declare const apiKeys: (client: Client) => {
    getAll: () => Promise<ArrayResult<ApiKey>>;
    get: (apiKeyId: string) => Promise<ApiKey>;
    create: (data: CreateApiKeyDto) => Promise<ApiKey>;
    update: (apiKeyId: string, data: UpdateApiKeyDto) => Promise<ApiKey>;
    delete: (apiKeyId: string) => Promise<ApiKey>;
};

declare const artists: (client: Client) => {
    top: (query?: Query<"/artists/top">) => Promise<ArrayResult<Artist>>;
    search: (query: Query<"/artists/search">) => Promise<ArrayResult<Artist>>;
    get: (query: Query<"/artists/:idOrPermalink">) => Promise<ArtistWithTracks>;
    follow: (query: Query<"/artists/:idOrPermalink/follow">) => Promise<{
        isFollowing: boolean;
    }>;
    unfollow: (query: Query<"/artists/:idOrPermalink/follow">) => Promise<{
        isFollowing: boolean;
    }>;
    events: (query: Query<"/artists/:idOrPermalink/events">) => Promise<ArrayResult<OrganizationEvent>>;
};

declare const auth: (client: Client) => {
    signIn: (data: SignInUserDto) => Promise<AuthResponse>;
    signUp: (data: CreateUserDto) => Promise<AuthResponse>;
    signOut: () => Promise<null>;
    refreshToken: () => Promise<AuthResponse>;
    recovery: (data: RecoveryDto) => Promise<RecoveryResponse>;
    recoveryReset: (data: RecoveryResetDto) => Promise<null>;
    verifyEmail: {
        send: () => Promise<VerifyEmailResponse>;
        confirm: (data: VerifyEmailConfirmDto) => Promise<null>;
    };
    oauth2: {
        connect: (provider: OAuth2Provider, params?: Record<string, ParamValue>) => string;
        disconnect: (provider: OAuth2Provider) => Promise<void>;
        googleOneTap: (data: GoogleOneTapDto) => Promise<AuthResponse>;
    };
};

declare function sdk<T>(builder: (client: Client) => T): (client: Client) => T;

declare const careers: (client: Client) => {
    categories: {
        getAll: (query?: Query<"/careers/categories">) => Promise<ArrayResult<CareersCategory>>;
    };
    employmentTypes: {
        getAll: (query?: Query<"/careers/employmentTypes">) => Promise<ArrayResult<CareersEmploymentType>>;
    };
    jobs: {
        getAll: (query?: Query<"/careers/jobs">) => Promise<ArrayResult<CareersJob>>;
        get: (jobId: number) => Promise<CareersJob>;
    };
    offices: {
        getAll: (query?: Query<"/careers/offices">) => Promise<ArrayResult<CareersOffice>>;
    };
};

declare const channels: (client: Client) => {
    me: (options?: ArrayOptions<Channel>) => Promise<ArrayResult<Channel>>;
    getByOrganization: (organizationSlug: string, options?: ArrayOptions<Channel>) => Promise<ArrayResult<Channel>>;
    countMe: (options?: UserChannelCountOptions) => Promise<number>;
    countByOrganization: (organizationSlug: string, options?: UserChannelCountOptions) => Promise<number>;
    get: (channelId: string) => Promise<Channel>;
    getByOrganizationChannel: (organizationSlug: string, channelId: string) => Promise<Channel>;
    create: (data: CreateChannelDto) => Promise<Channel>;
    createByOrganization: (organizationSlug: string, data: CreateChannelDto) => Promise<Channel>;
    update: (channelId: string, data: UpdateChannelDto) => Promise<Channel>;
    updateByOrganization: (organizationSlug: string, channelId: string, data: UpdateChannelDto) => Promise<Channel>;
    delete: (channelId: string) => Promise<void>;
    deleteByOrganization: (organizationSlug: string, channelId: string) => Promise<void>;
    addParticipant: (channelId: string, data: AddParticipantDto) => Promise<void>;
    addParticipantByOrganization: (organizationSlug: string, channelId: string, data: AddParticipantDto) => Promise<void>;
    removeParticipant: (channelId: string, username: string) => Promise<void>;
    removeParticipantByOrganization: (organizationSlug: string, channelId: string, username: string) => Promise<void>;
    getMembers: (channelId: string, options?: ArrayOptions<ChannelMember>) => Promise<ArrayResult<ChannelMember>>;
    getMembersByOrganization: (organizationSlug: string, channelId: string, options?: ArrayOptions<ChannelMember>) => Promise<ArrayResult<ChannelMember>>;
    messages: {
        getAll: (channelId: string, options?: ArrayOptions<ChannelMessage>) => Promise<ArrayResult<ChannelMessage>>;
        getAllByOrganization: (organizationSlug: string, channelId: string, options?: ArrayOptions<ChannelMessage>) => Promise<ArrayResult<ChannelMessage>>;
        get: (channelId: string, messageId: string) => Promise<ChannelMessage>;
        getByOrganization: (organizationSlug: string, channelId: string, messageId: string) => Promise<ChannelMessage>;
        create: (channelId: string, data: CreateChannelMessageDto) => Promise<ChannelMessage>;
        createByOrganization: (organizationSlug: string, channelId: string, data: CreateChannelMessageDto) => Promise<ChannelMessage>;
        update: (channelId: string, messageId: string, data: UpdateChannelMessageDto) => Promise<ChannelMessage>;
        updateByOrganization: (organizationSlug: string, channelId: string, messageId: string, data: UpdateChannelMessageDto) => Promise<ChannelMessage>;
        delete: (channelId: string, messageId: string) => Promise<void>;
        deleteByOrganization: (organizationSlug: string, channelId: string, messageId: string) => Promise<void>;
        addReaction: (channelId: string, messageId: string, data: AddReactionDto) => Promise<void>;
        addReactionByOrganization: (organizationSlug: string, channelId: string, messageId: string, data: AddReactionDto) => Promise<void>;
        removeReaction: (channelId: string, messageId: string, emoji: string) => Promise<void>;
        removeReactionByOrganization: (organizationSlug: string, channelId: string, messageId: string, emoji: string) => Promise<void>;
        markAsRead: (channelId: string, messageId: string) => Promise<void>;
        markAsReadByOrganization: (organizationSlug: string, channelId: string, messageId: string) => Promise<void>;
        uploadFile: (channelId: string, file: FormData) => Promise<string>;
        uploadFileByOrganization: (organizationSlug: string, channelId: string, file: FormData) => Promise<string>;
        report: (channelId: string, messageId: string, data: ReportChannelMessageDto) => Promise<void>;
        reportByOrganization: (organizationSlug: string, channelId: string, messageId: string, data: ReportChannelMessageDto) => Promise<void>;
    };
};

declare const currencies: (client: Client) => {
    getRates: () => Promise<ExchangeRates>;
    convert: (conversion: CurrencyConversion) => Promise<CurrencyConversionResult>;
    convertAmount: (from: Currency, to: Currency, amount: number) => Promise<CurrencyConversionResult>;
};

declare const feed: (client: Client) => {
    getFollowing: (options?: ArrayOptions<FeedPost>) => Promise<ArrayResult<FeedPost>>;
    getDiscover: (options?: ArrayOptions<FeedPost>) => Promise<ArrayResult<FeedPost>>;
};

declare const health: (client: Client) => {
    getAll: () => Promise<Health<"database" | "app" | "api">>;
    database: () => Promise<Health<"database">>;
    api: () => Promise<Health<"api">>;
    app: () => Promise<Health<"app">>;
    memory: () => Promise<HealthMemory>;
};

declare const notifications: (client: Client) => {
    registerToBeta: (email: string) => Promise<null>;
};

declare const orders: (client: Client) => {
    getAll: (options?: ArrayOptions<Order>) => Promise<ArrayResult<Order>>;
    get: (orderId: string) => Promise<Order>;
};

/**
 * Check if a currency is zero-decimal (no minor units).
 * For zero-decimal currencies, amounts are in the major unit (e.g., 500 JPY = 500 yen).
 */
declare function isZeroDecimalCurrency(currency: Currency): boolean;
/**
 * Convert a human-readable price to the smallest currency unit for Stripe.
 * For EUR/USD: 15.00 → 1500 (cents)
 * For JPY: 500 → 500 (yen, already smallest unit)
 */
declare function toSmallestUnit(amount: number, currency: Currency): number;
/**
 * Convert from smallest currency unit to human-readable price.
 * For EUR/USD: 1500 → 15.00
 * For JPY: 500 → 500
 */
declare function fromSmallestUnit(amount: number, currency: Currency): number;
type StripeFees = {
    transactionFee: number;
    europeRate: number;
    nonEuropeRate: number;
    connectRate: number;
};
type TonightPassFees = {
    percentage: number;
    minimumCommission: number;
};
declare enum BillingLocality {
    Europe = "Europe",
    NonEurope = "Non Europe"
}
type BillingParameters = {
    locality: BillingLocality;
};
/**
 * Minimum commission TonightPass charges per ticket (in EUR cents).
 */
declare const MINIMUM_COMMISSION = 95;
/**
 * Default minimum chargeable amount (in smallest currency unit).
 * Used as fallback when the currency has no specific Stripe minimum.
 */
declare const MINIMUM_CHARGEABLE_AMOUNT = 95;
declare const DEFAULT_STRIPE_FEES: StripeFees;
declare const DEFAULT_TONIGHTPASS_FEES: TonightPassFees;
declare const DEFAULT_BILLING_PARAMETERS: BillingParameters;
/**
 * Get the minimum chargeable amount for a currency (in smallest unit).
 * Falls back to the Stripe minimum for the currency, or MINIMUM_COMMISSION.
 */
declare function getMinimumChargeableAmount(currency: Currency): number;
/**
 * Calculate the platform fee for a ticket (in smallest currency unit).
 * @param ticketPrice - Ticket price in smallest unit (cents, yen, etc.)
 * @param isFeesIncluded - Whether fees are included in the ticket price
 * @param stripeFees - Stripe fee configuration
 * @param tonightPassFees - TonightPass fee configuration
 * @param params - Billing parameters (locality)
 * @returns Fee amount in smallest currency unit
 */
declare function calculateTicketFee(ticketPrice: number, isFeesIncluded: boolean, stripeFees?: StripeFees, tonightPassFees?: TonightPassFees, params?: BillingParameters): number;
/**
 * Calculate the platform fee for a ticket with currency-aware minimum commission.
 * Wraps `calculateTicketFee` with a converted minimum commission.
 *
 * @param ticketPrice - Ticket price in smallest unit (cents, yen, etc.)
 * @param isFeesIncluded - Whether fees are included in the ticket price
 * @param convertedMinimumCommission - MINIMUM_COMMISSION converted to the event's currency
 * @param stripeFees - Stripe fee configuration
 * @param params - Billing parameters (locality)
 * @returns Fee amount in smallest currency unit
 */
declare function calculateTicketFeeWithCurrency(ticketPrice: number, isFeesIncluded: boolean, convertedMinimumCommission: number, stripeFees?: StripeFees, params?: BillingParameters): number;
type CartTicket = {
    unitAmount: number;
    isFeesIncluded: boolean;
    quantity: number;
};
type OrderTotals = {
    subtotal: number;
    fees: number;
    includedFees: number;
    total: number;
};
/**
 * Calculate order totals from a cart of tickets.
 * Shared between frontend and backend to ensure consistent calculations.
 *
 * @param tickets - Array of tickets in the cart with unitAmount (smallest unit), isFeesIncluded, and quantity
 * @param convertedMinimumCommission - MINIMUM_COMMISSION converted to the event's currency (defaults to EUR 95 cents)
 * @returns Subtotal, fees, included fees, and total in smallest currency unit
 */
declare function calculateOrderTotal(tickets: CartTicket[], convertedMinimumCommission?: number): OrderTotals;
/**
 * Applies the minimum chargeable amount rule after a discount.
 * - If total is 0 → stays 0 (free order)
 * - If total > 0 but below the minimum → rounds up to minimum
 * - Otherwise → unchanged
 *
 * @param total - Order total in smallest currency unit
 * @param minimumAmount - Minimum chargeable amount in the same currency unit
 *   (use getMinimumChargeableAmount or convert MINIMUM_COMMISSION via exchange rates)
 */
declare function applyMinimumChargeableAmount(total: number, minimumAmount?: number): number;

declare const isBrowser: boolean;

/**
 * File object with uri/name/type structure
 */
type FileObject = {
    uri: string;
    name: string;
    type: string;
};
/**
 * Build a FormData object from a file or multiple files
 * @param key - The form field name for the file(s)
 * @param files - A single File, an array of Files, a FileList, or file object(s)
 * @returns FormData object with the file(s) appended
 */
declare function buildFileFormData(key: string, files: File | File[] | FileList | FileObject | FileObject[]): FormData;

/**
 * Check if a member role has at least the specified minimum role level
 * @param memberRole - The member's current role
 * @param minimumRole - The minimum required role
 * @returns true if memberRole has at least the power of minimumRole
 */
declare function isMemberRoleAtLeast(memberRole: OrganizationMemberRole, minimumRole: OrganizationMemberRole): boolean;

declare const organizations: (client: Client) => {
    search: (query: string, limit?: number) => Promise<Organization[]>;
    getAll: () => Promise<ArrayResult<Organization>>;
    get: (organizationSlug: string) => Promise<Organization>;
    create: (data: CreateOrganizationDto) => Promise<Organization>;
    update: (organizationSlug: string, data: UpdateOrganizationDto) => Promise<Organization>;
    delete: (organizationSlug: string) => Promise<Organization>;
    uploadFile: (organizationSlug: string, organizationFileType: OrganizationFileType, file: File | FileObject) => Promise<string>;
    billing: {
        account: (organizationSlug: string) => Promise<Stripe.Stripe.Account>;
        link: (organizationSlug: string) => void;
        balance: (organizationSlug: string) => Promise<OrganizationBillingBalance>;
        pending: (organizationSlug: string) => Promise<OrganizationBillingPendingRevenue>;
        dashboard: (organizationSlug: string) => void;
    };
    events: {
        search: (query: string, options?: ArrayOptions<OrganizationEvent>) => Promise<ArrayResult<OrganizationEvent>>;
        getCalendar: (year: number, month: number) => Promise<OrganizationEventCalendar>;
        getAll: (organizationSlug?: string, options?: OrganizationEventArrayOptions) => Promise<ArrayResult<OrganizationEvent>>;
        getSuggestions: (options?: ArrayOptions<OrganizationEvent>) => Promise<ArrayResult<OrganizationEvent>>;
        getNearby: (options: OrganizationEventNearbyOptions) => Promise<ArrayResult<OrganizationEvent>>;
        get: (organizationSlug: string, eventSlug: string) => Promise<OrganizationEvent>;
        create: (organizationSlug: string, data: CreateOrganizationEventDto) => Promise<OrganizationEvent>;
        update: (organizationSlug: string, eventSlug: string, data: UpdateOrganizationEventDto) => Promise<OrganizationEvent>;
        delete: (organizationSlug: string, eventSlug: string) => Promise<OrganizationEvent>;
        uploadFile: (eventFileType: OrganizationEventFileType, file: File | FileObject) => Promise<string>;
        uploadOrganizationFile: (organizationSlug: string, eventSlug: string, eventFileType: OrganizationEventFileType, file: File | FileObject) => Promise<string>;
        request: (organizationSlug: string, eventSlug: string) => Promise<OrganizationEventRequestResponse>;
        orders: {
            create: (organizationSlug: string, eventSlug: string, data: CreateOrganizationEventOrderDto) => Promise<Order>;
        };
        promoCodes: {
            getAll: (organizationSlug: string, eventSlug: string, options?: ArrayOptions<OrganizationEventPromoCode>) => Promise<ArrayResult<OrganizationEventPromoCode>>;
            create: (organizationSlug: string, eventSlug: string, data: CreateOrganizationEventPromoCodeDto) => Promise<OrganizationEventPromoCode>;
            update: (organizationSlug: string, eventSlug: string, promoCodeId: string, data: UpdateOrganizationEventPromoCodeDto) => Promise<OrganizationEventPromoCode>;
            delete: (organizationSlug: string, eventSlug: string, promoCodeId: string) => Promise<OrganizationEventPromoCode>;
            validate: (organizationSlug: string, eventSlug: string, code: string) => Promise<OrganizationEventPromoCodeValidation>;
        };
        styles: {
            getAll: (query?: pathcat.Query<"/organizations/events/styles">) => Promise<ArrayResult<OrganizationEventStyle>>;
            get: (styleSlug: string) => Promise<OrganizationEventStyle>;
            create: (data: CreateOrganizationEventStyleDto) => Promise<OrganizationEventStyle>;
            update: (styleSlug: string, data: UpdateOrganizationEventStyleDto) => Promise<OrganizationEventStyle>;
            delete: (styleSlug: string) => Promise<OrganizationEventStyle>;
        };
        tickets: {
            getAll: (organizationSlug: string, eventSlug: string) => Promise<OrganizationEventTicket[]>;
            get: (organizationSlug: string, eventSlug: string, ticketId: string) => Promise<OrganizationEventTicket>;
            create: (organizationSlug: string, eventSlug: string, data: CreateOrganizationEventTicketDto) => Promise<OrganizationEventTicket>;
            update: (organizationSlug: string, eventSlug: string, ticketId: string, data: UpdateOrganizationEventTicketDto) => Promise<OrganizationEventTicket>;
            delete: (organizationSlug: string, eventSlug: string, ticketId: string) => Promise<OrganizationEventTicket[]>;
        };
        views: {
            record: (organizationSlug: string, eventSlug: string) => Promise<boolean>;
            getStreamUrl: (options: OrganizationEventViewOptions) => string;
        };
    };
    members: {
        me: () => Promise<ArrayResult<OrganizationMember>>;
        get: (organizationSlug: string) => Promise<ArrayResult<OrganizationMember>>;
        create: (organizationSlug: string, data: CreateOrganizationMemberDto) => Promise<OrganizationMember>;
        update: (organizationSlug: string, username: string, data: UpdateOrganizationMemberDto) => Promise<OrganizationMember>;
        delete: (organizationSlug: string, username: string) => Promise<OrganizationMember[]>;
        invitations: {
            getLinks: (organizationSlug: string) => Promise<ArrayResult<OrganizationToken>>;
            createLink: (organizationSlug: string, data?: CreateOrganizationMemberInvitationLinkDto) => Promise<OrganizationToken>;
            accept: (organizationSlug: string, data: AcceptOrganizationMemberInvitationDto) => Promise<OrganizationMember>;
        };
        accept: (organizationSlug: string) => Promise<OrganizationMember>;
        reject: (organizationSlug: string) => Promise<null>;
        leave: (organizationSlug: string) => Promise<null>;
    };
    customers: {
        getAll: (organizationSlug: string) => Promise<ArrayResult<OrganizationCustomer>>;
        get: (organizationSlug: string, username: string) => Promise<OrganizationCustomer>;
    };
    orders: {
        getAll: (query?: pathcat.Query<"/organizations/@:organizationSlug/orders">) => Promise<ArrayResult<OrganizationOrder>>;
        get: (query: pathcat.Query<"/organizations/@:organizationSlug/orders/:orderId">) => Promise<OrganizationOrder>;
        getAllByEvent: (query?: pathcat.Query<"/organizations/@:organizationSlug/events/:eventSlug/orders">) => Promise<ArrayResult<OrganizationOrder>>;
        getBookingsByEvent: (query?: pathcat.Query<"/organizations/@:organizationSlug/events/:eventSlug/bookings">) => Promise<ArrayResult<UserBooking>>;
        getParticipantsByEvent: (query?: pathcat.Query<"/organizations/@:organizationSlug/events/:eventSlug/participants">) => Promise<ArrayResult<OrganizationCustomer>>;
    };
};

declare const places: (client: Client) => {
    countries: {
        getAll: (query?: Query<"/places/countries">) => Promise<ArrayResult<PlaceCountry>>;
        get: (query: Query<"/places/countries/:countrySlug">) => Promise<PlaceCountry>;
        cities: {
            getAll: (query: Query<"/places/countries/:countrySlug/cities">) => Promise<ArrayResult<PlaceCity>>;
            get: (query: Query<"/places/countries/:countrySlug/cities/:citySlug">) => Promise<PlaceCity | ExcludeBase<PlaceCity>>;
            nearby: (query: Query<"/places/countries/:countrySlug/cities/:citySlug/nearby">) => Promise<ArrayResult<Distance<PlaceCity>>>;
        };
    };
    cities: {
        getAll: (query?: Query<"/places/cities">) => Promise<ArrayResult<PlaceCity>>;
        search: (query: Query<"/places/cities/search">) => Promise<ArrayResult<PlaceCity>>;
    };
};

declare const profiles: (client: Client) => {
    getAll: (options?: ArrayOptions<Profile>) => Promise<ArrayResult<Profile>>;
    search: (query: string, options?: ArrayOptions<Profile>) => Promise<ArrayResult<Profile>>;
    get: (username: string) => Promise<Profile>;
    relationships: {
        follow: (username: string) => Promise<boolean>;
        unfollow: (username: string) => Promise<boolean>;
        getSuggestions: (options: ArrayOptions<UserIdentity | OrganizationIdentity>) => Promise<ArrayResult<Profile>>;
        getFollowers: (username: string, options: ArrayOptions<UserIdentity | OrganizationIdentity>) => Promise<ArrayResult<UserProfile>>;
    };
};

declare const roadmap: (client: Client) => {
    reactions: {
        get: (featureId: string) => Promise<RoadmapReactionCounts>;
        add: (featureId: string, reaction: RoadmapReaction) => Promise<RoadmapReactionCounts>;
    };
};

declare const sitemaps: (client: Client) => {
    getCounts: () => Promise<SitemapCounts>;
};

declare const users: (client: Client) => {
    getAll: () => Promise<User[]>;
    get: (userId: string) => Promise<User>;
    me: () => Promise<User>;
    check: (identifier: string, suggestions?: boolean) => Promise<{
        exists: boolean;
        identifier: Partial<UserIdentifier>;
        suggestions?: string[];
    }>;
    update: (userId: string, data: UpdateUserDto) => Promise<User>;
    uploadFile: (userId: string, userFileType: UserFileType, file: File | FileObject) => Promise<string>;
    uploadTempFile: (userFileType: UserFileType, file: File | FileObject) => Promise<string>;
    bookings: {
        getAll: () => Promise<ArrayResult<UserBooking>>;
        get: (bookingId: string) => Promise<UserBooking>;
        me: () => Promise<ArrayResult<UserBooking>>;
        tickets: {
            get: (ticketId: string) => Promise<UserBookingTicket>;
            use: (ticketId: string, tokenId: string, tokenValue: string) => Promise<UserBookingTicket>;
        };
    };
    notifications: {
        me: () => Promise<ArrayResult<UserNotificationFollow>>;
        count: (options: {
            unseen?: boolean;
        }) => Promise<number>;
        read: () => Promise<void>;
    };
    posts: {
        getByUsername: (username: string, options?: ArrayOptions<UserPost>) => Promise<ArrayResult<UserPost>>;
        getByUsernameAndId: (username: string, postId: string) => Promise<UserPost>;
        create: (data: CreateUserPostDto) => Promise<UserPost>;
        update: (postId: string, data: UpdateUserPostDto) => Promise<UserPost>;
        delete: (postId: string) => Promise<void>;
        uploadMedia: (file: FormData) => Promise<string>;
        views: {
            record: (username: string, postId: string) => Promise<boolean>;
        };
    };
    postsComments: {
        getByPost: (username: string, postId: string, options?: ArrayOptions<UserPostComment>) => Promise<ArrayResult<UserPostComment>>;
        create: (postId: string, data: CreateUserPostCommentDto) => Promise<UserPostComment>;
        update: (postId: string, commentId: string, data: UpdateUserPostCommentDto) => Promise<UserPostComment>;
        delete: (postId: string, commentId: string) => Promise<void>;
    };
    postsReposts: {
        getByUsername: (username: string, options?: ArrayOptions<UserPostRepost>) => Promise<ArrayResult<UserPostRepost>>;
        getByPost: (username: string, postId: string, options?: ArrayOptions<UserPostRepost>) => Promise<ArrayResult<UserPostRepost>>;
        create: (postId: string, data?: CreateUserPostRepostDto) => Promise<UserPostRepost>;
        delete: (postId: string) => Promise<void>;
    };
};

declare class TonightPass {
    readonly client: Client;
    readonly apiKeys: {
        getAll: () => Promise<ArrayResult<ApiKey>>;
        get: (apiKeyId: string) => Promise<ApiKey>;
        create: (data: CreateApiKeyDto) => Promise<ApiKey>;
        update: (apiKeyId: string, data: UpdateApiKeyDto) => Promise<ApiKey>;
        delete: (apiKeyId: string) => Promise<ApiKey>;
    };
    readonly artists: {
        top: (query?: pathcat.Query<"/artists/top">) => Promise<ArrayResult<Artist>>;
        search: (query: pathcat.Query<"/artists/search">) => Promise<ArrayResult<Artist>>;
        get: (query: pathcat.Query<"/artists/:idOrPermalink">) => Promise<ArtistWithTracks>;
        follow: (query: pathcat.Query<"/artists/:idOrPermalink/follow">) => Promise<{
            isFollowing: boolean;
        }>;
        unfollow: (query: pathcat.Query<"/artists/:idOrPermalink/follow">) => Promise<{
            isFollowing: boolean;
        }>;
        events: (query: pathcat.Query<"/artists/:idOrPermalink/events">) => Promise<ArrayResult<OrganizationEvent>>;
    };
    readonly auth: {
        signIn: (data: SignInUserDto) => Promise<AuthResponse>;
        signUp: (data: CreateUserDto) => Promise<AuthResponse>;
        signOut: () => Promise<null>;
        refreshToken: () => Promise<AuthResponse>;
        recovery: (data: RecoveryDto) => Promise<RecoveryResponse>;
        recoveryReset: (data: RecoveryResetDto) => Promise<null>;
        verifyEmail: {
            send: () => Promise<VerifyEmailResponse>;
            confirm: (data: VerifyEmailConfirmDto) => Promise<null>;
        };
        oauth2: {
            connect: (provider: OAuth2Provider, params?: Record<string, pathcat.ParamValue>) => string;
            disconnect: (provider: OAuth2Provider) => Promise<void>;
            googleOneTap: (data: GoogleOneTapDto) => Promise<AuthResponse>;
        };
    };
    readonly careers: {
        categories: {
            getAll: (query?: pathcat.Query<"/careers/categories">) => Promise<ArrayResult<CareersCategory>>;
        };
        employmentTypes: {
            getAll: (query?: pathcat.Query<"/careers/employmentTypes">) => Promise<ArrayResult<CareersEmploymentType>>;
        };
        jobs: {
            getAll: (query?: pathcat.Query<"/careers/jobs">) => Promise<ArrayResult<CareersJob>>;
            get: (jobId: number) => Promise<CareersJob>;
        };
        offices: {
            getAll: (query?: pathcat.Query<"/careers/offices">) => Promise<ArrayResult<CareersOffice>>;
        };
    };
    readonly channels: {
        me: (options?: ArrayOptions<Channel>) => Promise<ArrayResult<Channel>>;
        getByOrganization: (organizationSlug: string, options?: ArrayOptions<Channel>) => Promise<ArrayResult<Channel>>;
        countMe: (options?: UserChannelCountOptions) => Promise<number>;
        countByOrganization: (organizationSlug: string, options?: UserChannelCountOptions) => Promise<number>;
        get: (channelId: string) => Promise<Channel>;
        getByOrganizationChannel: (organizationSlug: string, channelId: string) => Promise<Channel>;
        create: (data: CreateChannelDto) => Promise<Channel>;
        createByOrganization: (organizationSlug: string, data: CreateChannelDto) => Promise<Channel>;
        update: (channelId: string, data: UpdateChannelDto) => Promise<Channel>;
        updateByOrganization: (organizationSlug: string, channelId: string, data: UpdateChannelDto) => Promise<Channel>;
        delete: (channelId: string) => Promise<void>;
        deleteByOrganization: (organizationSlug: string, channelId: string) => Promise<void>;
        addParticipant: (channelId: string, data: AddParticipantDto) => Promise<void>;
        addParticipantByOrganization: (organizationSlug: string, channelId: string, data: AddParticipantDto) => Promise<void>;
        removeParticipant: (channelId: string, username: string) => Promise<void>;
        removeParticipantByOrganization: (organizationSlug: string, channelId: string, username: string) => Promise<void>;
        getMembers: (channelId: string, options?: ArrayOptions<ChannelMember>) => Promise<ArrayResult<ChannelMember>>;
        getMembersByOrganization: (organizationSlug: string, channelId: string, options?: ArrayOptions<ChannelMember>) => Promise<ArrayResult<ChannelMember>>;
        messages: {
            getAll: (channelId: string, options?: ArrayOptions<ChannelMessage>) => Promise<ArrayResult<ChannelMessage>>;
            getAllByOrganization: (organizationSlug: string, channelId: string, options?: ArrayOptions<ChannelMessage>) => Promise<ArrayResult<ChannelMessage>>;
            get: (channelId: string, messageId: string) => Promise<ChannelMessage>;
            getByOrganization: (organizationSlug: string, channelId: string, messageId: string) => Promise<ChannelMessage>;
            create: (channelId: string, data: CreateChannelMessageDto) => Promise<ChannelMessage>;
            createByOrganization: (organizationSlug: string, channelId: string, data: CreateChannelMessageDto) => Promise<ChannelMessage>;
            update: (channelId: string, messageId: string, data: UpdateChannelMessageDto) => Promise<ChannelMessage>;
            updateByOrganization: (organizationSlug: string, channelId: string, messageId: string, data: UpdateChannelMessageDto) => Promise<ChannelMessage>;
            delete: (channelId: string, messageId: string) => Promise<void>;
            deleteByOrganization: (organizationSlug: string, channelId: string, messageId: string) => Promise<void>;
            addReaction: (channelId: string, messageId: string, data: AddReactionDto) => Promise<void>;
            addReactionByOrganization: (organizationSlug: string, channelId: string, messageId: string, data: AddReactionDto) => Promise<void>;
            removeReaction: (channelId: string, messageId: string, emoji: string) => Promise<void>;
            removeReactionByOrganization: (organizationSlug: string, channelId: string, messageId: string, emoji: string) => Promise<void>;
            markAsRead: (channelId: string, messageId: string) => Promise<void>;
            markAsReadByOrganization: (organizationSlug: string, channelId: string, messageId: string) => Promise<void>;
            uploadFile: (channelId: string, file: FormData) => Promise<string>;
            uploadFileByOrganization: (organizationSlug: string, channelId: string, file: FormData) => Promise<string>;
            report: (channelId: string, messageId: string, data: ReportChannelMessageDto) => Promise<void>;
            reportByOrganization: (organizationSlug: string, channelId: string, messageId: string, data: ReportChannelMessageDto) => Promise<void>;
        };
    };
    readonly currencies: {
        getRates: () => Promise<ExchangeRates>;
        convert: (conversion: CurrencyConversion) => Promise<CurrencyConversionResult>;
        convertAmount: (from: Currency, to: Currency, amount: number) => Promise<CurrencyConversionResult>;
    };
    readonly feed: {
        getFollowing: (options?: ArrayOptions<FeedPost>) => Promise<ArrayResult<FeedPost>>;
        getDiscover: (options?: ArrayOptions<FeedPost>) => Promise<ArrayResult<FeedPost>>;
    };
    readonly health: {
        getAll: () => Promise<Health<"database" | "app" | "api">>;
        database: () => Promise<Health<"database">>;
        api: () => Promise<Health<"api">>;
        app: () => Promise<Health<"app">>;
        memory: () => Promise<HealthMemory>;
    };
    readonly orders: {
        getAll: (options?: ArrayOptions<Order>) => Promise<ArrayResult<Order>>;
        get: (orderId: string) => Promise<Order>;
    };
    readonly organizations: {
        search: (query: string, limit?: number) => Promise<Organization[]>;
        getAll: () => Promise<ArrayResult<Organization>>;
        get: (organizationSlug: string) => Promise<Organization>;
        create: (data: CreateOrganizationDto) => Promise<Organization>;
        update: (organizationSlug: string, data: UpdateOrganizationDto) => Promise<Organization>;
        delete: (organizationSlug: string) => Promise<Organization>;
        uploadFile: (organizationSlug: string, organizationFileType: OrganizationFileType, file: File | FileObject) => Promise<string>;
        billing: {
            account: (organizationSlug: string) => Promise<Stripe.Stripe.Account>;
            link: (organizationSlug: string) => void;
            balance: (organizationSlug: string) => Promise<OrganizationBillingBalance>;
            pending: (organizationSlug: string) => Promise<OrganizationBillingPendingRevenue>;
            dashboard: (organizationSlug: string) => void;
        };
        events: {
            search: (query: string, options?: ArrayOptions<OrganizationEvent>) => Promise<ArrayResult<OrganizationEvent>>;
            getCalendar: (year: number, month: number) => Promise<OrganizationEventCalendar>;
            getAll: (organizationSlug?: string, options?: OrganizationEventArrayOptions) => Promise<ArrayResult<OrganizationEvent>>;
            getSuggestions: (options?: ArrayOptions<OrganizationEvent>) => Promise<ArrayResult<OrganizationEvent>>;
            getNearby: (options: OrganizationEventNearbyOptions) => Promise<ArrayResult<OrganizationEvent>>;
            get: (organizationSlug: string, eventSlug: string) => Promise<OrganizationEvent>;
            create: (organizationSlug: string, data: CreateOrganizationEventDto) => Promise<OrganizationEvent>;
            update: (organizationSlug: string, eventSlug: string, data: UpdateOrganizationEventDto) => Promise<OrganizationEvent>;
            delete: (organizationSlug: string, eventSlug: string) => Promise<OrganizationEvent>;
            uploadFile: (eventFileType: OrganizationEventFileType, file: File | FileObject) => Promise<string>;
            uploadOrganizationFile: (organizationSlug: string, eventSlug: string, eventFileType: OrganizationEventFileType, file: File | FileObject) => Promise<string>;
            request: (organizationSlug: string, eventSlug: string) => Promise<OrganizationEventRequestResponse>;
            orders: {
                create: (organizationSlug: string, eventSlug: string, data: CreateOrganizationEventOrderDto) => Promise<Order>;
            };
            promoCodes: {
                getAll: (organizationSlug: string, eventSlug: string, options?: ArrayOptions<OrganizationEventPromoCode>) => Promise<ArrayResult<OrganizationEventPromoCode>>;
                create: (organizationSlug: string, eventSlug: string, data: CreateOrganizationEventPromoCodeDto) => Promise<OrganizationEventPromoCode>;
                update: (organizationSlug: string, eventSlug: string, promoCodeId: string, data: UpdateOrganizationEventPromoCodeDto) => Promise<OrganizationEventPromoCode>;
                delete: (organizationSlug: string, eventSlug: string, promoCodeId: string) => Promise<OrganizationEventPromoCode>;
                validate: (organizationSlug: string, eventSlug: string, code: string) => Promise<OrganizationEventPromoCodeValidation>;
            };
            styles: {
                getAll: (query?: pathcat.Query<"/organizations/events/styles">) => Promise<ArrayResult<OrganizationEventStyle>>;
                get: (styleSlug: string) => Promise<OrganizationEventStyle>;
                create: (data: CreateOrganizationEventStyleDto) => Promise<OrganizationEventStyle>;
                update: (styleSlug: string, data: UpdateOrganizationEventStyleDto) => Promise<OrganizationEventStyle>;
                delete: (styleSlug: string) => Promise<OrganizationEventStyle>;
            };
            tickets: {
                getAll: (organizationSlug: string, eventSlug: string) => Promise<OrganizationEventTicket[]>;
                get: (organizationSlug: string, eventSlug: string, ticketId: string) => Promise<OrganizationEventTicket>;
                create: (organizationSlug: string, eventSlug: string, data: CreateOrganizationEventTicketDto) => Promise<OrganizationEventTicket>;
                update: (organizationSlug: string, eventSlug: string, ticketId: string, data: UpdateOrganizationEventTicketDto) => Promise<OrganizationEventTicket>;
                delete: (organizationSlug: string, eventSlug: string, ticketId: string) => Promise<OrganizationEventTicket[]>;
            };
            views: {
                record: (organizationSlug: string, eventSlug: string) => Promise<boolean>;
                getStreamUrl: (options: OrganizationEventViewOptions) => string;
            };
        };
        members: {
            me: () => Promise<ArrayResult<OrganizationMember>>;
            get: (organizationSlug: string) => Promise<ArrayResult<OrganizationMember>>;
            create: (organizationSlug: string, data: CreateOrganizationMemberDto) => Promise<OrganizationMember>;
            update: (organizationSlug: string, username: string, data: UpdateOrganizationMemberDto) => Promise<OrganizationMember>;
            delete: (organizationSlug: string, username: string) => Promise<OrganizationMember[]>;
            invitations: {
                getLinks: (organizationSlug: string) => Promise<ArrayResult<OrganizationToken>>;
                createLink: (organizationSlug: string, data?: CreateOrganizationMemberInvitationLinkDto) => Promise<OrganizationToken>;
                accept: (organizationSlug: string, data: AcceptOrganizationMemberInvitationDto) => Promise<OrganizationMember>;
            };
            accept: (organizationSlug: string) => Promise<OrganizationMember>;
            reject: (organizationSlug: string) => Promise<null>;
            leave: (organizationSlug: string) => Promise<null>;
        };
        customers: {
            getAll: (organizationSlug: string) => Promise<ArrayResult<OrganizationCustomer>>;
            get: (organizationSlug: string, username: string) => Promise<OrganizationCustomer>;
        };
        orders: {
            getAll: (query?: pathcat.Query<"/organizations/@:organizationSlug/orders">) => Promise<ArrayResult<OrganizationOrder>>;
            get: (query: pathcat.Query<"/organizations/@:organizationSlug/orders/:orderId">) => Promise<OrganizationOrder>;
            getAllByEvent: (query?: pathcat.Query<"/organizations/@:organizationSlug/events/:eventSlug/orders">) => Promise<ArrayResult<OrganizationOrder>>;
            getBookingsByEvent: (query?: pathcat.Query<"/organizations/@:organizationSlug/events/:eventSlug/bookings">) => Promise<ArrayResult<UserBooking>>;
            getParticipantsByEvent: (query?: pathcat.Query<"/organizations/@:organizationSlug/events/:eventSlug/participants">) => Promise<ArrayResult<OrganizationCustomer>>;
        };
    };
    readonly places: {
        countries: {
            getAll: (query?: pathcat.Query<"/places/countries">) => Promise<ArrayResult<PlaceCountry>>;
            get: (query: pathcat.Query<"/places/countries/:countrySlug">) => Promise<PlaceCountry>;
            cities: {
                getAll: (query: pathcat.Query<"/places/countries/:countrySlug/cities">) => Promise<ArrayResult<PlaceCity>>;
                get: (query: pathcat.Query<"/places/countries/:countrySlug/cities/:citySlug">) => Promise<PlaceCity | ExcludeBase<PlaceCity>>;
                nearby: (query: pathcat.Query<"/places/countries/:countrySlug/cities/:citySlug/nearby">) => Promise<ArrayResult<Distance<PlaceCity>>>;
            };
        };
        cities: {
            getAll: (query?: pathcat.Query<"/places/cities">) => Promise<ArrayResult<PlaceCity>>;
            search: (query: pathcat.Query<"/places/cities/search">) => Promise<ArrayResult<PlaceCity>>;
        };
    };
    readonly profiles: {
        getAll: (options?: ArrayOptions<Profile>) => Promise<ArrayResult<Profile>>;
        search: (query: string, options?: ArrayOptions<Profile>) => Promise<ArrayResult<Profile>>;
        get: (username: string) => Promise<Profile>;
        relationships: {
            follow: (username: string) => Promise<boolean>;
            unfollow: (username: string) => Promise<boolean>;
            getSuggestions: (options: ArrayOptions<UserIdentity | OrganizationIdentity>) => Promise<ArrayResult<Profile>>;
            getFollowers: (username: string, options: ArrayOptions<UserIdentity | OrganizationIdentity>) => Promise<ArrayResult<UserProfile>>;
        };
    };
    readonly roadmap: {
        reactions: {
            get: (featureId: string) => Promise<RoadmapReactionCounts>;
            add: (featureId: string, reaction: RoadmapReaction) => Promise<RoadmapReactionCounts>;
        };
    };
    readonly sitemaps: {
        getCounts: () => Promise<SitemapCounts>;
    };
    readonly users: {
        getAll: () => Promise<User[]>;
        get: (userId: string) => Promise<User>;
        me: () => Promise<User>;
        check: (identifier: string, suggestions?: boolean) => Promise<{
            exists: boolean;
            identifier: Partial<UserIdentifier>;
            suggestions?: string[];
        }>;
        update: (userId: string, data: UpdateUserDto) => Promise<User>;
        uploadFile: (userId: string, userFileType: UserFileType, file: File | FileObject) => Promise<string>;
        uploadTempFile: (userFileType: UserFileType, file: File | FileObject) => Promise<string>;
        bookings: {
            getAll: () => Promise<ArrayResult<UserBooking>>;
            get: (bookingId: string) => Promise<UserBooking>;
            me: () => Promise<ArrayResult<UserBooking>>;
            tickets: {
                get: (ticketId: string) => Promise<UserBookingTicket>;
                use: (ticketId: string, tokenId: string, tokenValue: string) => Promise<UserBookingTicket>;
            };
        };
        notifications: {
            me: () => Promise<ArrayResult<UserNotificationFollow>>;
            count: (options: {
                unseen?: boolean;
            }) => Promise<number>;
            read: () => Promise<void>;
        };
        posts: {
            getByUsername: (username: string, options?: ArrayOptions<UserPost>) => Promise<ArrayResult<UserPost>>;
            getByUsernameAndId: (username: string, postId: string) => Promise<UserPost>;
            create: (data: CreateUserPostDto) => Promise<UserPost>;
            update: (postId: string, data: UpdateUserPostDto) => Promise<UserPost>;
            delete: (postId: string) => Promise<void>;
            uploadMedia: (file: FormData) => Promise<string>;
            views: {
                record: (username: string, postId: string) => Promise<boolean>;
            };
        };
        postsComments: {
            getByPost: (username: string, postId: string, options?: ArrayOptions<UserPostComment>) => Promise<ArrayResult<UserPostComment>>;
            create: (postId: string, data: CreateUserPostCommentDto) => Promise<UserPostComment>;
            update: (postId: string, commentId: string, data: UpdateUserPostCommentDto) => Promise<UserPostComment>;
            delete: (postId: string, commentId: string) => Promise<void>;
        };
        postsReposts: {
            getByUsername: (username: string, options?: ArrayOptions<UserPostRepost>) => Promise<ArrayResult<UserPostRepost>>;
            getByPost: (username: string, postId: string, options?: ArrayOptions<UserPostRepost>) => Promise<ArrayResult<UserPostRepost>>;
            create: (postId: string, data?: CreateUserPostRepostDto) => Promise<UserPostRepost>;
            delete: (postId: string) => Promise<void>;
        };
    };
    readonly notifications: {
        registerToBeta: (email: string) => Promise<null>;
    };
    constructor(options: ClientOptions);
}

interface ChannelMessageCreateEvent extends WebSocketEvent<ChannelMessage> {
    type: "channel_message_create";
}
interface ChannelMessageUpdateEvent extends WebSocketEvent<ChannelMessage> {
    type: "channel_message_update";
}
interface ChannelMessageDeleteEvent extends WebSocketEvent<{
    id: string;
    channelId: string;
}> {
    type: "channel_message_delete";
}
interface ChannelUpdateEvent extends WebSocketEvent<Channel> {
    type: "channel_update";
}
interface ChannelDeleteEvent extends WebSocketEvent<{
    id: string;
}> {
    type: "channel_delete";
}
interface ChannelMemberJoinEvent extends WebSocketEvent<{
    channel: Channel;
    user: User;
}> {
    type: "channel_member_join";
}
interface ChannelMemberLeaveEvent extends WebSocketEvent<{
    channelId: string;
    userId: string;
}> {
    type: "channel_member_leave";
}
interface TypingStartEvent extends WebSocketEvent<{
    channelId: string;
    userId: string;
    username: string;
}> {
    type: "typing_start";
}
interface TypingStopEvent extends WebSocketEvent<{
    channelId: string;
    userId: string;
}> {
    type: "typing_stop";
}
type ChannelWebSocketEvent = ChannelMessageCreateEvent | ChannelMessageUpdateEvent | ChannelMessageDeleteEvent | ChannelUpdateEvent | ChannelDeleteEvent | ChannelMemberJoinEvent | ChannelMemberLeaveEvent | TypingStartEvent | TypingStopEvent;

type WebSocketEvent<T = unknown> = {
    type: string;
    data: T;
};
type WebSocketConnectOptions = {
    token?: string;
    channelId?: string;
    organizationSlug?: string;
};
type WebSocketClientOptions = {
    baseURL: string;
    reconnectInterval?: number;
    maxReconnectAttempts?: number;
    debug?: boolean;
};

type GETEndpoints = Extract<Endpoints, {
    method: "GET";
}>;
type RESTEndpointPaths = GETEndpoints["path"];
type WebSocketPath<T extends string> = T extends `${RESTEndpointPaths}/ws` ? T : never;
type WebSocketEndpoint<Path extends string, ConnectOptions = undefined> = {
    path: WebSocketPath<Path>;
    options: ConnectOptions;
};
type WebSocketEndpoints = WebSocketEndpoint<"/channels/~me/ws", WebSocketConnectOptions> | WebSocketEndpoint<"/channels/~me/:channelId/ws", WebSocketConnectOptions & {
    channelId: string;
}> | WebSocketEndpoint<"/channels/:organizationSlug/ws", WebSocketConnectOptions & {
    organizationSlug: string;
}> | WebSocketEndpoint<"/channels/:organizationSlug/:channelId/ws", WebSocketConnectOptions & {
    organizationSlug: string;
    channelId: string;
}>;
type WebSocketPaths = WebSocketEndpoints["path"];
type WebSocketPathsFor = Extract<WebSocketEndpoints, {
    path: string;
}>["path"];
type WebSocketOptionsFor<P extends WebSocketPaths> = Extract<WebSocketEndpoints, {
    path: P;
}>["options"];

type WebSocketEventHandler<T> = (event: T) => void;
declare class WebSocketClient {
    private ws?;
    private readonly options;
    private reconnectAttempts;
    private reconnectTimer?;
    private readonly eventHandlers;
    private isConnected;
    private isReconnecting;
    constructor(options?: Partial<WebSocketClientOptions>);
    private log;
    private getWebSocketURL;
    connect<P extends WebSocketPaths>(path: P, options: WebSocketOptionsFor<P>): Promise<void>;
    private handleReconnect;
    private handleEvent;
    on<T extends ChannelWebSocketEvent>(eventType: T["type"] | "*", handler: WebSocketEventHandler<T>): () => void;
    off<T extends ChannelWebSocketEvent>(eventType: T["type"] | "*", _handler: WebSocketEventHandler<T>): void;
    send(data: unknown): void;
    disconnect(): void;
    get connected(): boolean;
    get reconnecting(): boolean;
}

declare class ChannelWebSocketClient extends WebSocketClient {
    connectToChannel(channelId: string, options?: WebSocketConnectOptions): Promise<void>;
    connectToOrganizationChannel(organizationSlug: string, channelId: string, options?: WebSocketConnectOptions): Promise<void>;
    connectToUserChannels(options?: WebSocketConnectOptions): Promise<void>;
    connectToOrganizationChannels(organizationSlug: string, options?: WebSocketConnectOptions): Promise<void>;
    onMessageCreate(handler: WebSocketEventHandler<ChannelMessageCreateEvent>): () => void;
    onMessageUpdate(handler: WebSocketEventHandler<ChannelMessageUpdateEvent>): () => void;
    onMessageDelete(handler: WebSocketEventHandler<ChannelMessageDeleteEvent>): () => void;
    onChannelUpdate(handler: WebSocketEventHandler<ChannelUpdateEvent>): () => void;
    onChannelDelete(handler: WebSocketEventHandler<ChannelDeleteEvent>): () => void;
    onMemberJoin(handler: WebSocketEventHandler<ChannelMemberJoinEvent>): () => void;
    onMemberLeave(handler: WebSocketEventHandler<ChannelMemberLeaveEvent>): () => void;
    onTypingStart(handler: WebSocketEventHandler<TypingStartEvent>): () => void;
    onTypingStop(handler: WebSocketEventHandler<TypingStopEvent>): () => void;
    startTyping(channelId: string): void;
    stopTyping(channelId: string): void;
    subscribeToChannel(channelId: string): void;
    unsubscribeFromChannel(channelId: string): void;
}

declare function channelsWS(options?: Partial<WebSocketClientOptions>): {
    connect: (channelId: string, token?: string) => Promise<void>;
    connectToOrganization: (organizationSlug: string, channelId: string, token?: string) => Promise<void>;
    connectToUserChannels: (token?: string) => Promise<void>;
    connectToOrganizationChannels: (organizationSlug: string, token?: string) => Promise<void>;
    onMessageCreate: (handler: Parameters<(handler: WebSocketEventHandler<ChannelMessageCreateEvent>) => () => void>[0]) => () => void;
    onMessageUpdate: (handler: Parameters<(handler: WebSocketEventHandler<ChannelMessageUpdateEvent>) => () => void>[0]) => () => void;
    onMessageDelete: (handler: Parameters<(handler: WebSocketEventHandler<ChannelMessageDeleteEvent>) => () => void>[0]) => () => void;
    onChannelUpdate: (handler: Parameters<(handler: WebSocketEventHandler<ChannelUpdateEvent>) => () => void>[0]) => () => void;
    onChannelDelete: (handler: Parameters<(handler: WebSocketEventHandler<ChannelDeleteEvent>) => () => void>[0]) => () => void;
    onMemberJoin: (handler: Parameters<(handler: WebSocketEventHandler<ChannelMemberJoinEvent>) => () => void>[0]) => () => void;
    onMemberLeave: (handler: Parameters<(handler: WebSocketEventHandler<ChannelMemberLeaveEvent>) => () => void>[0]) => () => void;
    onTypingStart: (handler: Parameters<(handler: WebSocketEventHandler<TypingStartEvent>) => () => void>[0]) => () => void;
    onTypingStop: (handler: Parameters<(handler: WebSocketEventHandler<TypingStopEvent>) => () => void>[0]) => () => void;
    onAny: (handler: Parameters<(<T extends ChannelWebSocketEvent>(eventType: T["type"] | "*", handler: WebSocketEventHandler<T>) => () => void)>[1]) => () => void;
    startTyping: (channelId: string) => void;
    stopTyping: (channelId: string) => void;
    subscribeToChannel: (channelId: string) => void;
    unsubscribeFromChannel: (channelId: string) => void;
    disconnect: () => void;
    readonly connected: boolean;
    readonly reconnecting: boolean;
    client: ChannelWebSocketClient;
};

export { type APIRequestOptions, type APIResponse, AcceptOrganizationMemberInvitationDto, AddParticipantDto, AddReactionDto, type AddRoadmapReactionBody, type AnalyticsOptions, type ApiKey, type ApiKeyEndpoints, ApiKeyTier, ApiKeyType, type ArrayFilterOptions, type ArrayOptions, type ArrayPaginationOptions, type ArrayResult, type ArraySortOptions, type Artist, type ArtistEndpoints, type ArtistSoundcloudBadges, type ArtistSoundcloudData, type ArtistSoundcloudWebProfile, type ArtistTonightPassData, type ArtistTrack, type ArtistWithTracks, AtLeastOneMedia, AtLeastOneMediaConstraint, AtLeastOneMediaOnUpdate, AtLeastOneMediaOnUpdateConstraint, type AuthEndpoints, AuthFlow, type AuthMethod, type AuthResponse, type Base, BaseOrganizationEventDto, type BaseProfile, type BaseProfileMetadata, BillingLocality, type BillingParameters, type Body, type CacheEntry, CacheManager, type CacheOptions, type CacheStore, type CareerEndpoints, type CareersCategoriesOptions, type CareersCategory, type CareersEmploymentType, type CareersEmploymentTypesOptions, type CareersJob, CareersJobStatus, type CareersJobsOptions, type CareersOffice, type CareersOfficesOptions, CareersRemoteType, CareersWorkplaceType, type CartTicket, type Channel, type ChannelDeleteEvent, type ChannelEndpoints, type ChannelMember, type ChannelMemberJoinEvent, type ChannelMemberLeaveEvent, ChannelMemberRole, type ChannelMessage, type ChannelMessageCreateEvent, type ChannelMessageDeleteEvent, type ChannelMessageEndpoints, type ChannelMessageReaction, type ChannelMessageReadByEntry, ChannelMessageReportReason, type ChannelMessageUpdateEvent, type ChannelParticipant, ChannelStatus, ChannelType, type ChannelUpdateEvent, ChannelWebSocketClient, type ChannelWebSocketEvent, Client, type ClientOptions, ContentOrAttachmentsConstraint, CreateApiKeyDto, CreateChannelDto, CreateChannelMessageDto, CreateLocationDto, CreateOrganizationDto, CreateOrganizationEventDto, type CreateOrganizationEventInput, CreateOrganizationEventOrderDto, CreateOrganizationEventPromoCodeDto, CreateOrganizationEventStyleDto, CreateOrganizationEventTicketDto, type CreateOrganizationEventTicketInput, CreateOrganizationIdentityDto, CreateOrganizationMemberDto, CreateOrganizationMemberInvitationLinkDto, CreateUserDto, CreateUserIdentityDto, CreateUserPostCommentDto, CreateUserPostDto, CreateUserPostRepostDto, type CurrenciesEndpoints, Currency, type CurrencyConversion, type CurrencyConversionResult, DEFAULT_API_URL, DEFAULT_BILLING_PARAMETERS, DEFAULT_STRIPE_FEES, DEFAULT_TONIGHTPASS_FEES, type DeepPartial, type Distance, type Endpoint, type Endpoints, ErrorType, type ErroredAPIResponse, type EventAnalyticsOptions, EventArtistDto, type EventArtistRef, type ExchangeRates, type ExcludeBase, type ExternalContact, type ExternalOffer, type ExternalSource, type FeedEndpoints, type FeedPost, FeedType, type FileObject, type GeoPoint, GeoPointDto, type GeoSearchAggregation, type GetArtistOptions, GoogleOneTapDto, type Health, type HealthEndpoints, type HealthMemory, Language, type ListArtistEventsOptions, type ListPlaceCountriesOptions, type ListTopArtistsOptions, type Location$1 as Location, MINIMUM_CHARGEABLE_AMOUNT, MINIMUM_CHARGE_AMOUNTS, MINIMUM_COMMISSION, MemoryCacheStore, type MemorySnapshot, type NearbyCitiesOptions, type NotificationEndpoints, OAuth2Provider, type Order, type OrderDiscount, type OrderEndpoints, type OrderItem, type OrderTotals, OrderTransferStatus, type Organization, type OrganizationAnalyticsEndpoints, type OrganizationAnalyticsOverview, type OrganizationBilling, type OrganizationBillingAccount, type OrganizationBillingBalance, type OrganizationBillingPendingRevenue, type OrganizationCustomer, type OrganizationCustomerMetadata, type OrganizationCustomersEndpoints, type OrganizationEndpoints, type OrganizationEvent, type OrganizationEventAnalytics, type OrganizationEventArrayOptions, type OrganizationEventCalendar, type OrganizationEventEndpoints, OrganizationEventFileType, type OrganizationEventNearbyOptions, type OrganizationEventOrderEndpoints, type OrganizationEventPromoCode, type OrganizationEventPromoCodeEndpoints, OrganizationEventPromoCodeType, type OrganizationEventPromoCodeValidation, type OrganizationEventRequestResponse, OrganizationEventStatus, type OrganizationEventStyle, type OrganizationEventStyleEndpoints, OrganizationEventStyleType, type OrganizationEventTicket, OrganizationEventTicketCategory, type OrganizationEventTicketEndpoints, OrganizationEventTicketType, OrganizationEventType, type OrganizationEventViewEndpoints, type OrganizationEventViewOptions, type OrganizationEventViewResult, OrganizationEventVisibilityType, OrganizationFileType, type OrganizationIdentity, type OrganizationMember, OrganizationMemberRole, OrganizationMemberRolePower, OrganizationMemberStatus, type OrganizationMembersEndpoints, type OrganizationNotification, type OrganizationNotificationBase, type OrganizationNotificationEndpoints, OrganizationNotificationType, type OrganizationNotificationWithActor, type OrganizationOrder, type OrganizationOrdersEndpoints, OrganizationPayoutStatus, type OrganizationProfile, type OrganizationProfileMetadata, type OrganizationToken, OrganizationTokenType, type PathsFor, type PlaceCity, type PlaceCountry, type PlaceEndpoints, type Profile, type ProfileEndpoints, type ProfileMetadata, ProfileType, type PromisedAPIResponse, type PromisedResponse, type ProxyEndpoints, type ProxyMediaOptions, type ProxyMediaResponse, type QueryParams, REGEX, ROADMAP_REACTIONS, RecoveryDto, RecoveryResetDto, type RecoveryResponse, ReportChannelMessageDto, type Response, type ResponseFor, type RoadmapEndpoints, type RoadmapFeature, RoadmapFeatureStatus, type RoadmapReaction, type RoadmapReactionCounts, type SSEEndpoints, type SearchArtistsOptions, type SearchOrganizationEventsOptions, type SearchPlacesOptions, type SearchProfilesOptions, SignInUserDto, type SitemapCounts, type SitemapEndpoints, type StringifiedQuery, type StringifiedQueryValue, type StripeFees, type SuccessfulAPIResponse, TonightPass, TonightPassAPIError, type TonightPassFees, type TypingStartEvent, type TypingStopEvent, UpdateApiKeyDto, UpdateChannelDto, UpdateChannelMessageDto, UpdateLocationDto, UpdateOrganizationDto, UpdateOrganizationEventDto, UpdateOrganizationEventPromoCodeDto, UpdateOrganizationEventStyleDto, UpdateOrganizationEventTicketDto, UpdateOrganizationIdentityDto, UpdateOrganizationMemberDto, UpdateUserDto, UpdateUserPostCommentDto, UpdateUserPostDto, type User, type UserBooking, type UserBookingEndpoints, type UserBookingTicket, type UserBookingTicketEndpoints, type UserBookingWithoutTickets, type UserChannelCountOptions, type UserConnection, type UserConnectionClient, type UserConnectionDevice, type UserConnectionOS, type UserCustomer, type UserCustomerMetadata, type UserEndpoints, UserFileType, type UserIdentifier, type UserIdentity, UserIdentityGender, type UserNotification, type UserNotificationBase, type UserNotificationEndpoints, type UserNotificationFollow, UserNotificationType, type UserOAuthProvider, type UserPost, type UserPostComment, type UserPostCommentEndpoints, type UserPostEndpoints, type UserPostMedia, type UserPostMediaEndpoints, UserPostMediaType, type UserPostRepost, type UserPostRepostEndpoints, type UserPostViewEndpoints, type UserPostViewOptions, type UserPostViewResult, UserPostVisibility, type UserPreferences, type UserProfile, type UserProfileMetadata, UserRole, UserRolePower, type UserToken, UserTokenType, VerifyEmailConfirmDto, type VerifyEmailResponse, type WeatherEndpoints, type WeatherForecast, WebSocketClient, type WebSocketClientOptions, type WebSocketConnectOptions, type WebSocketEndpoint, type WebSocketEndpoints, type WebSocketEvent, type WebSocketEventHandler, type WebSocketOptionsFor, type WebSocketPath, type WebSocketPaths, type WebSocketPathsFor, type WebhookEndpoints, ZERO_DECIMAL_CURRENCIES, apiKeys, applyMinimumChargeableAmount, artists, auth, buildFileFormData, calculateOrderTotal, calculateTicketFee, calculateTicketFeeWithCurrency, careers, channels, channelsWS, currencies, feed, fromSmallestUnit, getMinimumChargeableAmount, health, isBrowser, isMemberRoleAtLeast, isZeroDecimalCurrency, normalizeAddress, notifications, orders, organizations, places, profiles, request, roadmap, sdk, sitemaps, toSmallestUnit, users };