tonightpass/dist/index.d.ts

@tonightpass sdk and tools.

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

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

declare const REGEX: {
    EMAIL: 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;
};

type Endpoint<M extends Options["method"], Path extends string, Res, Body = undefined> = {
    method: M;
    path: Path;
    res: Res;
    body: Body;
};
type Endpoints = AuthEndpoints | CareerEndpoints | HealthEndpoints | OrderEndpoints | OrganizationEndpoints | ProfileEndpoints | UserEndpoints | WebhookEndpoints | NotificationEndpoints;

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

type Order = Base & {
    invoice: Stripe__default.Invoice;
    user: User;
};
type OrderEndpoints = Endpoint<"GET", "/orders", ArrayResult<Order>, ArrayOptions<Order>> | Endpoint<"GET", "/orders/:orderId", Order>;

type UserBookingTicket = Base & {
    booking: UserBooking;
    ticket: OrganizationEventTicket;
    token: UserToken;
    useCount: number;
};
type UserBooking = Base & {
    tickets: UserBookingTicket[];
    order: Order;
    user: User;
    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> | Endpoint<"GET", "/users/bookings/tickets/:ticketId", UserBookingTicket, {
    tokenId: string;
    tokenValue: string;
}>;

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 PublicUser = {
    identifier: Pick<UserIdentifier, "username">;
    identity: {
        displayName: string;
        avatarUrl: string;
        slug: string;
        type: ProfileType;
        metadata: UserProfileMetadata;
    };
};
type User = Base & {
    identifier: UserIdentifier;
    password: string;
    identity: UserIdentity;
    role: UserRole;
    addresses: Location$1[];
    preferences: UserPreferences;
    connections: UserConnection[];
    verified: boolean;
};
type UserIdentifier = {
    email?: string;
    phoneNumber?: string;
    username: string;
    [key: string]: string | undefined;
};
type UserIdentity = UserProfile & {
    firstName: string;
    lastName: string;
    fullName: string;
    gender: UserIdentityGender;
    birthDate: 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 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/search", PublicUser[], {
    q: string;
    limit?: number;
}> | 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> | UserBookingEndpoints | UserNotificationEndpoints;

type AuthEndpoints = Endpoint<"POST", "/auth/sign-up", User, CreateUserDto> | Endpoint<"POST", "/auth/sign-in", User, SignInUserDto> | Endpoint<"POST", "/auth/sign-out", null, null> | Endpoint<"POST", "/auth/refresh-token", null, null> | Endpoint<"GET", "/oauth2/google", void> | Endpoint<"GET", "/oauth2/google/callback", void> | Endpoint<"GET", "/oauth2/facebook", void> | Endpoint<"GET", "/oauth2/facebook/callback", void> | Endpoint<"GET", "/oauth2/twitter", void> | Endpoint<"GET", "/oauth2/twitter/callback", void>;

type CareersOffice = {
    id: number | null;
    isDefault: boolean | null;
    name: string | null;
    city: string | null;
    countryIso: string | null;
};
type CareersJob = {
    id: number;
    createdAt: string;
    lastUpdatedAt: string;
    externalId: null | string;
    title: string;
    status: "ALL" | "ONLINE" | "ARCHIVED";
    remote: boolean;
    office: CareersOffice;
    workplaceType: "ONSITE" | "REMOTE" | "HYBRID";
    remoteType?: "ANYWHERE" | "COUNTRY";
    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 CareerEndpoints = Endpoint<"GET", "/careers/categories", CareersCategory[], {
    language?: string;
}> | Endpoint<"GET", "/careers/employmentTypes", CareersEmploymentType[], {
    language?: string;
}> | Endpoint<"GET", "/careers/jobs", CareersJob[], {
    page?: number;
    pageSize?: number;
    createdAtGte: string;
    createdAtLt?: string;
    updatedAtGte?: string;
    updatedAtLt?: string;
    status?: "ALL" | "ONLINE" | "ARCHIVED";
    content?: boolean;
    titleLike?: string;
    countryCode?: string;
    externalId?: string;
}> | Endpoint<"GET", "/careers/jobs/:jobId", CareersJob, {
    jobId: number;
}> | Endpoint<"GET", "/careers/offices", CareersOffice[], {
    page?: number;
    pageSize?: number;
    countryCode?: string;
    cityNameLike?: string;
}>;

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"
}

interface Health<T extends string = string> extends HealthCheckResult {
    info?: Record<T, HealthIndicatorResult[T]>;
    error?: Record<T, HealthIndicatorResult[T]>;
    details: Record<T, HealthIndicatorResult[T]>;
}
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">>;

/**
 * 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;
};
interface GeoSearchAggregation<T> {
    metadata: {
        total: number;
    }[];
    data: T[];
}
type Distance<T> = T & {
    distance: number;
};

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", 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[], null>;

type OrganizationEventViewEndpoints = Endpoint<"POST", "/organizations/:organizationSlug/events/:eventSlug/views", boolean, null>;

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: Organization;
    type: OrganizationEventType;
    visibility: OrganizationEventVisibilityType;
    flyers: string[];
    trailers: string[];
    location: Location$1;
    tickets: OrganizationEventTicket[];
    styles: OrganizationEventStyle[];
    viewsCount: number;
    startAt: Date;
    endAt: Date;
};
declare enum OrganizationEventType {
    Clubbing = "clubbing",
    Concert = "concert",
    Afterwork = "afterwork",
    DancingLunch = "dancing_lunch",
    Diner = "diner",
    Garden = "garden",
    AfterBeach = "after_beach",
    Festival = "festival",
    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"
}
type OrganizationEventEndpoints = Endpoint<"GET", "/organizations/events/search", OrganizationEvent[], {
    q: string;
    limit?: number;
}> | Endpoint<"GET", "/organizations/events", ArrayResult<OrganizationEvent>, ArrayOptions<OrganizationEvent>> | Endpoint<"GET", "/organizations/events/suggestions", ArrayResult<OrganizationEvent>, ArrayOptions<OrganizationEvent>> | Endpoint<"GET", "/organizations/events/nearby", ArrayResult<OrganizationEvent>, ArrayOptions<OrganizationEvent> & {
    latitude: number;
    longitude: number;
    radius?: number;
}> | Endpoint<"GET", "/organizations/:organizationSlug/events", ArrayResult<OrganizationEvent>, ArrayOptions<OrganizationEvent>> | Endpoint<"GET", "/organizations/:organizationSlug/events/past", ArrayResult<OrganizationEvent>, ArrayOptions<OrganizationEvent>> | Endpoint<"GET", "/organizations/:organizationSlug/events/upcoming", ArrayResult<OrganizationEvent>, ArrayOptions<OrganizationEvent>> | 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> | OrganizationEventOrderEndpoints | OrganizationEventStyleEndpoints | OrganizationEventTicketEndpoints | OrganizationEventViewEndpoints;

declare class UpdateOrganizationMemberDto {
    role: OrganizationMemberRole;
}

type OrganizationMember = Base & {
    organization: Organization;
    role: OrganizationMemberRole;
    status: OrganizationMemberStatus;
    user?: User;
    token?: UserToken;
};
declare enum OrganizationMemberStatus {
    Pending = "pending",
    Accepted = "accepted",
    Rejected = "rejected"
}
declare enum OrganizationMemberRole {
    Member = "member",
    Manager = "manager",
    Admin = "admin",
    Owner = "owner"
}
type OrganizationMembersEndpoints = Endpoint<"GET", "/organizations/members", ArrayResult<OrganizationMember>, ArrayOptions<OrganizationMember>> | Endpoint<"GET", "/organizations/members/@me", ArrayResult<OrganizationMember>, ArrayOptions<OrganizationMember>> | Endpoint<"DELETE", "/organizations/members/:memberId", OrganizationMember[], null> | Endpoint<"GET", "/organizations/:organizationSlug/members", ArrayResult<OrganizationMember>, ArrayOptions<OrganizationMember>> | Endpoint<"POST", "/organizations/:organizationSlug/members", OrganizationMember, CreateOrganizationMemberDto> | Endpoint<"PUT", "/organizations/:organizationSlug/members/:userId", OrganizationMember, UpdateOrganizationMemberDto> | Endpoint<"DELETE", "/organizations/:organizationSlug/members/:userId", OrganizationMember[], null>;

type Organization = Base & {
    slug: string;
    identity: OrganizationIdentity;
    members: OrganizationMember[];
    location?: Location$1;
    events: OrganizationEvent[];
    savedTickets: OrganizationEventTicket[];
    verified: boolean;
    billing: OrganizationBilling;
};
type OrganizationBilling = {
    account: string;
};
type OrganizationBillingAccount = Stripe__default.Account;
type OrganizationIdentity = OrganizationProfile & {
    socialLinks: OrganizationSocialLink[];
};
type OrganizationSocialLink = {
    type: OrganizationSocialType;
    url: string;
};
declare enum OrganizationSocialType {
    Facebook = "facebook",
    Twitter = "twitter",
    Instagram = "instagram",
    Linkedin = "linkedin",
    Youtube = "youtube",
    Website = "website"
}
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, null> | Endpoint<"GET", "/organizations/:organizationSlug/billing/account", OrganizationBillingAccount> | Endpoint<"GET", "/organizations/:organizationSlug/billing/link", void> | Endpoint<"GET", "/organizations/:organizationSlug/billing/dashboard", void> | OrganizationEventEndpoints | OrganizationMembersEndpoints;

declare enum ProfileType {
    User = "user",
    Organization = "organization"
}
type BaseProfile = {
    type: ProfileType;
    slug: string;
    displayName: string;
    description?: string;
    avatarUrl?: string;
    bannerUrl?: 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;
};
type UserProfileMetadata = BaseProfileMetadata & {
    hasPassPlus: boolean;
    idValid: boolean;
};
type OrganizationProfileMetadata = BaseProfileMetadata & {
    eventsCount: number;
    viewsCount: number;
    membersCount: number;
};
type ProfileMetadata = UserProfileMetadata | OrganizationProfileMetadata;
type ProfileEndpoints = Endpoint<"GET", "/profiles/:username", Profile> | Endpoint<"GET", "/profiles/@me/relationships/suggestions", ArrayResult<Profile>, ArrayOptions<Organization | User>> | Endpoint<"GET", "/profiles/:username/relationships/followers", ArrayResult<UserProfile>, ArrayOptions<User>> | Endpoint<"POST", "/profiles/:username/relationships/follow", boolean, null> | Endpoint<"POST", "/profiles/:username/relationships/unfollow", boolean, null>;

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

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

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 Currency {
    EUR = "EUR",
    USD = "USD",
    GBP = "GBP"
}
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> = {} & ArrayPaginationOptions;
type ArrayResult<T> = {
    items: T[];
    total: number;
    page: number;
    limit: number;
};

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

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;
    socialLinks?: OrganizationSocialLink[];
}

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

declare class CreateOrganizationEventOrderDto {
    cart: 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;
    currency: Currency;
    isVisible: boolean;
    isFeesIncluded: boolean;
    startAt?: Date;
    endAt?: Date;
}

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

type CreateOrganizationEventInput = Omit<ExcludeBase<OrganizationEvent>, "slug" | "styles" | "tickets" | "organization" | "viewsCount"> & {
    slug?: string;
    styles: string[];
    tickets: CreateOrganizationEventTicketInput[];
};
declare class CreateOrganizationEventDto implements CreateOrganizationEventInput {
    title: string;
    slug?: string;
    description: string;
    type: OrganizationEventType;
    visibility: OrganizationEventVisibilityType;
    flyers: string[];
    trailers: string[];
    location: CreateLocationDto;
    tickets: CreateOrganizationEventTicketDto[];
    styles: string[];
    startAt: Date;
    endAt: Date;
}

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[];
    startAt?: Date;
    endAt?: Date;
}

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;
}

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;
}

type SuccessfulAPIResponse<T> = {
    success: true;
    data: T;
};
type ErroredAPIResponse = {
    success: false;
    message: string;
    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);
}
interface ClientOptions {
    readonly baseURL: string;
}
declare class Client {
    private options;
    readonly url: (path: string, params: Record<string, ParamValue>) => string;
    constructor(options: ClientOptions);
    setOptions(options: ClientOptions): void;
    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;
}

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

declare const auth: (client: Client) => {
    signIn: (data: SignInUserDto) => Promise<User>;
    signUp: (data: CreateUserDto) => Promise<User>;
    signOut: () => Promise<null>;
    refreshToken: () => Promise<null>;
    oauth2: {
        google: {
            connect: (params?: Record<string, ParamValue>) => void;
        };
        twitter: {
            connect: (params?: Record<string, ParamValue>) => void;
        };
        facebook: {
            connect: (params?: Record<string, ParamValue>) => void;
        };
    };
};

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

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

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

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

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>;
    billing: {
        account: (organizationSlug: string) => Promise<Stripe.Stripe.Account>;
        link: (organizationSlug: string) => void;
        dashboard: (organizationSlug: string) => void;
    };
    events: {
        search: (query: string, limit?: number) => Promise<OrganizationEvent[]>;
        getAll: (organizationSlug?: string, options?: ArrayOptions<OrganizationEvent>) => Promise<ArrayResult<OrganizationEvent>>;
        getSuggestions: (options?: ArrayOptions<OrganizationEvent>) => Promise<ArrayResult<OrganizationEvent>>;
        getNearby: (options: ArrayOptions<OrganizationEvent> & {
            latitude: number;
            longitude: number;
            radius?: number;
        }) => Promise<ArrayResult<OrganizationEvent>>;
        getPast: (organizationSlug: string, options?: ArrayOptions<OrganizationEvent>) => Promise<ArrayResult<OrganizationEvent>>;
        getUpcoming: (organizationSlug: string, options?: ArrayOptions<OrganizationEvent>) => 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>;
        orders: {
            create: (organizationSlug: string, eventSlug: string, data: CreateOrganizationEventOrderDto) => Promise<Order>;
        };
        styles: {
            getAll: () => Promise<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>;
        };
    };
    members: {
        getAll: () => Promise<ArrayResult<OrganizationMember>>;
        delete: (memberId: string) => Promise<OrganizationMember[]>;
    };
};

declare const profiles: (client: Client) => {
    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 users: (client: Client) => {
    search: (query: string, limit?: number) => Promise<PublicUser[]>;
    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) => Promise<string>;
    bookings: {
        getAll: () => Promise<ArrayResult<UserBooking>>;
        get: (bookingId: string) => Promise<UserBooking>;
        me: () => Promise<ArrayResult<UserBooking>>;
    };
    notifications: {
        me: () => Promise<ArrayResult<UserNotificationFollow>>;
        count: (options: {
            unseen?: boolean;
        }) => Promise<number>;
    };
};

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

declare class TonightPass {
    readonly client: Client;
    readonly auth: {
        signIn: (data: SignInUserDto) => Promise<User>;
        signUp: (data: CreateUserDto) => Promise<User>;
        signOut: () => Promise<null>;
        refreshToken: () => Promise<null>;
        oauth2: {
            google: {
                connect: (params?: Record<string, pathcat.ParamValue>) => void;
            };
            twitter: {
                connect: (params?: Record<string, pathcat.ParamValue>) => void;
            };
            facebook: {
                connect: (params?: Record<string, pathcat.ParamValue>) => void;
            };
        };
    };
    readonly careers: {
        categories: {
            getAll: (query?: pathcat.Query<"/careers/categories">) => Promise<CareersCategory[]>;
        };
        employmentTypes: {
            getAll: (query?: pathcat.Query<"/careers/employmentTypes">) => Promise<CareersEmploymentType[]>;
        };
        jobs: {
            getAll: (query?: pathcat.Query<"/careers/jobs">) => Promise<CareersJob[]>;
            get: (jobId: number) => Promise<CareersJob>;
        };
        offices: {
            getAll: (query?: pathcat.Query<"/careers/offices">) => Promise<CareersOffice[]>;
        };
    };
    readonly health: {
        getAll: () => Promise<Health<"database" | "app" | "api">>;
        database: () => Promise<Health<"database">>;
        api: () => Promise<Health<"api">>;
        app: () => Promise<Health<"app">>;
    };
    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>;
        billing: {
            account: (organizationSlug: string) => Promise<Stripe.Stripe.Account>;
            link: (organizationSlug: string) => void;
            dashboard: (organizationSlug: string) => void;
        };
        events: {
            search: (query: string, limit?: number) => Promise<OrganizationEvent[]>;
            getAll: (organizationSlug?: string, options?: ArrayOptions<OrganizationEvent>) => Promise<ArrayResult<OrganizationEvent>>;
            getSuggestions: (options?: ArrayOptions<OrganizationEvent>) => Promise<ArrayResult<OrganizationEvent>>;
            getNearby: (options: ArrayOptions<OrganizationEvent> & {
                latitude: number;
                longitude: number;
                radius?: number;
            }) => Promise<ArrayResult<OrganizationEvent>>;
            getPast: (organizationSlug: string, options?: ArrayOptions<OrganizationEvent>) => Promise<ArrayResult<OrganizationEvent>>;
            getUpcoming: (organizationSlug: string, options?: ArrayOptions<OrganizationEvent>) => 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>;
            orders: {
                create: (organizationSlug: string, eventSlug: string, data: CreateOrganizationEventOrderDto) => Promise<Order>;
            };
            styles: {
                getAll: () => Promise<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>;
            };
        };
        members: {
            getAll: () => Promise<ArrayResult<OrganizationMember>>;
            delete: (memberId: string) => Promise<OrganizationMember[]>;
        };
    };
    readonly profiles: {
        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 users: {
        search: (query: string, limit?: number) => Promise<PublicUser[]>;
        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) => Promise<string>;
        bookings: {
            getAll: () => Promise<ArrayResult<UserBooking>>;
            get: (bookingId: string) => Promise<UserBooking>;
            me: () => Promise<ArrayResult<UserBooking>>;
        };
        notifications: {
            me: () => Promise<ArrayResult<UserNotificationFollow>>;
            count: (options: {
                unseen?: boolean;
            }) => Promise<number>;
        };
    };
    readonly notifications: {
        registerToBeta: (email: string) => Promise<null>;
    };
    constructor(options: ClientOptions);
}

declare const isBrowser: boolean;
declare function buildFileFormData(key: string, files: File | File[] | FileList): FormData;

export { type APIRequestOptions, type APIResponse, type ArrayFilterOptions, type ArrayOptions, type ArrayPaginationOptions, type ArrayResult, type ArraySortOptions, type AuthEndpoints, type Base, type BaseProfile, type BaseProfileMetadata, type Body, type CareerEndpoints, type CareersCategory, type CareersEmploymentType, type CareersJob, type CareersOffice, Client, type ClientOptions, CreateLocationDto, CreateOrganizationDto, CreateOrganizationEventDto, type CreateOrganizationEventInput, CreateOrganizationEventOrderDto, CreateOrganizationEventStyleDto, CreateOrganizationEventTicketDto, type CreateOrganizationEventTicketInput, CreateOrganizationIdentityDto, CreateOrganizationMemberDto, CreateUserDto, CreateUserIdentityDto, Currency, DEFAULT_API_URL, type DeepPartial, type Distance, type Endpoint, type Endpoints, ErrorType, type ErroredAPIResponse, type ExcludeBase, type GeoPoint, GeoPointDto, type GeoSearchAggregation, type Health, type HealthEndpoints, Language, type Location$1 as Location, type NotificationEndpoints, type Order, type OrderEndpoints, type Organization, type OrganizationBilling, type OrganizationBillingAccount, type OrganizationEndpoints, type OrganizationEvent, type OrganizationEventEndpoints, type OrganizationEventOrderEndpoints, type OrganizationEventStyle, type OrganizationEventStyleEndpoints, OrganizationEventStyleType, type OrganizationEventTicket, OrganizationEventTicketCategory, type OrganizationEventTicketEndpoints, OrganizationEventTicketType, OrganizationEventType, OrganizationEventVisibilityType, type OrganizationIdentity, type OrganizationMember, OrganizationMemberRole, OrganizationMemberStatus, type OrganizationMembersEndpoints, type OrganizationProfile, type OrganizationProfileMetadata, type OrganizationSocialLink, OrganizationSocialType, type PathsFor, type Profile, type ProfileEndpoints, type ProfileMetadata, ProfileType, type PromisedAPIResponse, type PromisedResponse, type PublicUser, type QueryParams, REGEX, type Response, type ResponseFor, SignInUserDto, type StringifiedQuery, type StringifiedQueryValue, type SuccessfulAPIResponse, TonightPass, TonightPassAPIError, UpdateLocationDto, UpdateOrganizationDto, UpdateOrganizationEventDto, UpdateOrganizationEventStyleDto, UpdateOrganizationEventTicketDto, UpdateOrganizationIdentityDto, UpdateOrganizationMemberDto, UpdateUserDto, type User, type UserBooking, type UserBookingEndpoints, type UserBookingTicket, type UserConnection, type UserConnectionClient, type UserConnectionDevice, type UserConnectionOS, type UserEndpoints, UserFileType, type UserIdentifier, type UserIdentity, UserIdentityGender, type UserNotification, type UserNotificationBase, type UserNotificationEndpoints, type UserNotificationFollow, UserNotificationType, type UserPreferences, type UserProfile, type UserProfileMetadata, UserRole, type UserToken, UserTokenType, type WebhookEndpoints, auth, buildFileFormData, careers, health, isBrowser, notifications, orders, organizations, profiles, request, sdk, users };