tonightpass/dist/index.d.mts

@tonightpass sdk and tools.

import * as pathcat from 'pathcat';
import { ParamValue, Query } from 'pathcat';
export * from 'pathcat';
import { Options, Response as Response$1 } from 'redaxios';
import * as Stripe from 'stripe';
import Stripe__default from 'stripe';
import { ValidatorConstraintInterface, ValidationArguments, ValidationOptions } from 'class-validator';
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;
};

declare class AddParticipantDto {
    username: string;
}

type Endpoint<M extends Options["method"], Path extends string, Res, Body = undefined> = {
    method: M;
    path: Path;
    res: Res;
    body: Body;
};
type Endpoints = AuthEndpoints | CareerEndpoints | ChannelEndpoints | ChannelMessageEndpoints | CurrenciesEndpoints | 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: UserProfile;
};
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 UserBookingWithoutTickets = Omit<UserBooking, "tickets">;
type UserBookingTicket = Base & {
    booking: UserBookingWithoutTickets;
    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[];
    isVerified: boolean;
    isOfficial: 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 RecoveryResponse = {
    to: string;
};
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<"POST", "/auth/recovery", RecoveryResponse, RecoveryDto> | Endpoint<"POST", "/auth/recovery/reset", null, RecoveryResetDto> | 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 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> | Endpoint<"DELETE", "/channels/:organizationSlug/:channelId/messages/:messageId", void> | 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> | Endpoint<"DELETE", "/channels/:organizationSlug/:channelId/messages/:messageId/reactions/:emoji", void> | Endpoint<"POST", "/channels/@me/:channelId/messages/:messageId/read", void, null> | Endpoint<"POST", "/channels/:organizationSlug/:channelId/messages/:messageId/read", void, null> | 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> | Endpoint<"DELETE", "/channels/:organizationSlug/:channelId", void> | Endpoint<"POST", "/channels/@me/:channelId/participants", void, AddParticipantDto> | Endpoint<"POST", "/channels/:organizationSlug/:channelId/participants", void, AddParticipantDto> | Endpoint<"DELETE", "/channels/@me/:channelId/participants/:username", void> | Endpoint<"DELETE", "/channels/:organizationSlug/:channelId/participants/:username", void> | Endpoint<"GET", "/channels/@me/:channelId/members", ArrayResult<ChannelMember>, ArrayOptions<ChannelMember>> | Endpoint<"GET", "/channels/:organizationSlug/:channelId/members", ArrayResult<ChannelMember>, ArrayOptions<ChannelMember>>;

declare enum Currency {
    EUR = "EUR",
    USD = "USD",
    GBP = "GBP",
    BGN = "BGN",
    CZK = "CZK",
    DKK = "DKK",
    HUF = "HUF",
    PLN = "PLN",
    RON = "RON",
    SEK = "SEK",
    CHF = "CHF",
    NOK = "NOK",
    ISK = "ISK",
    TRY = "TRY",
    RUB = "RUB",
    UAH = "UAH",
    BAM = "BAM",
    MKD = "MKD",
    ALL = "ALL",
    RSD = "RSD",
    MDL = "MDL",
    GEL = "GEL",
    BYN = "BYN"
}
interface ExchangeRates {
    base: Currency.EUR;
    rates: Record<Currency, number>;
    updatedAt: Date;
}
interface CurrencyConversion {
    from: Currency;
    to: Currency;
    amount: number;
}
interface 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>;

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: OrganizationProfile;
    type: OrganizationEventType;
    visibility: OrganizationEventVisibilityType;
    flyers: string[];
    trailers: string[];
    location: Location$1;
    tickets: OrganizationEventTicket[];
    styles: OrganizationEventStyle[];
    status: OrganizationEventStatus;
    viewsCount: number;
    sessionsCount: number;
    totalViewsCount: number;
    averageViewsPerSessionCount: 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"
}
declare enum OrganizationEventFileType {
    Flyer = "flyer",
    Trailer = "trailer"
}
declare enum OrganizationEventStatus {
    Upcoming = "upcoming",
    Ongoing = "ongoing",
    Ended = "ended"
}
type OrganizationEventArrayOptions = ArrayOptions<OrganizationEvent> & {
    status?: OrganizationEventStatus | OrganizationEventStatus[];
};
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>, 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> | OrganizationEventOrderEndpoints | 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: {
        totalViews: number;
        uniqueViews: number;
        sessionsCount: 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>;

declare class AcceptOrganizationMemberInvitationDto {
    token: string;
}

declare class CreateOrganizationMemberInvitationLinkDto {
    role?: OrganizationMemberRole;
}

declare class UpdateOrganizationMemberDto {
    role: OrganizationMemberRole;
}

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

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[], null> | 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, null> | Endpoint<"DELETE", "/organizations/:organizationSlug/members/@me/reject", null, null> | Endpoint<"DELETE", "/organizations/:organizationSlug/members/@me", null, 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;
    vatRate: number;
};
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 | OrganizationAnalyticsEndpoints;

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;
    isOfficial: boolean;
};
type UserProfileMetadata = BaseProfileMetadata & {
    hasPassPlus: 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<OrganizationProfile | UserProfile>> | Endpoint<"GET", "/profiles/:username/relationships/followers", ArrayResult<UserProfile>, ArrayOptions<UserProfile>> | 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 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 CreateChannelDto {
    type: ChannelType;
    participantUsernames: string[];
    name?: string;
}

declare class UpdateChannelDto {
    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 UpdateChannelMessageDto {
    content?: string;
}

declare class ReportChannelMessageDto {
    reason: ChannelMessageReportReason;
    description?: 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;
}

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

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" | "organization" | "status" | "viewsCount" | "sessionsCount" | "totalViewsCount" | "averageViewsPerSessionCount"> & {
    slug?: string;
    styles: string[];
    tickets: CreateOrganizationEventTicketInput[];
};
declare class BaseOrganizationEventDto {
    title: string;
    slug?: string;
    description: string;
    type: OrganizationEventType;
    visibility: OrganizationEventVisibilityType;
    flyers: string[];
    trailers: string[];
    location: CreateLocationDto;
    styles: string[];
    startAt: Date;
    endAt: Date;
}
declare class CreateOrganizationEventDto extends BaseOrganizationEventDto implements CreateOrganizationEventInput {
    tickets: CreateOrganizationEventTicketDto[];
}

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

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);
}
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>;
    recovery: (data: RecoveryDto) => Promise<RecoveryResponse>;
    recoveryReset: (data: RecoveryResetDto) => 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 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 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: