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

interface CacheEntry<T> {
    data: T;
    timestamp: number;
}
interface CacheOptions {
    enabled: boolean;
    ttl?: number;
    methods?: Options["method"][];
}
declare class CacheManager {
    private cache;
    private options;
    constructor(options: CacheOptions);
    private generateKey;
    private shouldCache;
    private isValid;
    get<T>(method: Options["method"], url: string): T | null;
    set<T>(method: Options["method"], url: string, data: T): void;
    clear(): void;
    stats(): {
        size: number;
        keys: string[];
    };
}

type CreateApiKeyDto = {
    name: string;
};

type UpdateApiKeyDto = {
    name?: string;
    isActive?: boolean;
};

declare class AddParticipantDto {
    username: string;
}

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;
    links?: string[];
}

declare class UpdateOrganizationMemberDto {
    role: OrganizationMemberRole;
}

declare class AcceptOrganizationMemberInvitationDto {
    token: string;
}

declare class CreateOrganizationMemberInvitationLinkDto {
    role?: OrganizationMemberRole;
}

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

declare class CreateOrganizationEventOrderDto {
    cart: string[];
}

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

declare class UpdateOrganizationEventStyleDto extends CreateOrganizationEventStyleDto {
}

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;
    links?: string[];
}

declare class GoogleOneTapDto {
    credential: string;
}

declare class RecoveryDto {
    identifier: string;
}

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

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

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

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

declare class UpdateUserPostCommentDto {
    content: string;
}

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

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

declare class CreateUserPostRepostDto {
    comment?: string;
}

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

type UserPostViewEndpoints = Endpoint<"POST", "/users/@:username/posts/:postId/views", boolean, null>;

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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",
    Festival = "festival",
    HouseParty = "house_party",
    FriendsParty = "friends_party",
    Afterwork = "afterwork",
    DancingLunch = "dancing_lunch",
    Diner = "diner",
    Garden = "garden",
    AfterBeach = "after_beach",
    Spectacle = "spectacle",
    Cruise = "cruise",
    OutsideAnimation = "outside_animation",
    Sport = "sport",
    Match = "match",
    Seminar = "seminar",
    Conference = "conference",
    WellnessDay = "wellness_day",
    Workshop = "workshop",
    TradeFair = "trade_fair",
    ConsumerShow = "consumer_show",
    Membership = "membership"
}
declare enum OrganizationEventVisibilityType {
    Public = "public",
    Unlisted = "unlisted",
    Private = "private"
}
declare enum OrganizationEventFileType {
    Flyer = "flyer",
    Trailer = "trailer"
}
declare enum OrganizationEventStatus {
    Upcoming = "upcoming",
    Ongoing = "ongoing",
    Ended = "ended"
}
type OrganizationEventArrayOptions = ArrayOptions<OrganizationEvent> & {
    status?: OrganizationEventStatus | OrganizationEventStatus[];
    types?: OrganizationEventType | OrganizationEventType[];
    styles?: string | string[];
};
type SearchOrganizationEventsOptions = ArrayOptions<OrganizationEvent> & {
    q: string;
};
type OrganizationEventCalendar = {
    [date: string]: OrganizationEvent[];
};
type OrganizationEventEndpoints = Endpoint<"GET", "/organizations/events/search", ArrayResult<OrganizationEvent>, SearchOrganizationEventsOptions> | Endpoint<"GET", "/organizations/events/calendar/:year/:month", OrganizationEventCalendar> | Endpoint<"GET", "/organizations/events", ArrayResult<OrganizationEvent>, OrganizationEventArrayOptions> | Endpoint<"GET", "/organizations/events/suggestions", ArrayResult<OrganizationEvent>, ArrayOptions<OrganizationEvent>> | Endpoint<"GET", "/organizations/events/nearby", ArrayResult<OrganizationEvent>, 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>;

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

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 OrganizationOrder = Omit<Order, "user"> & {
    customer: OrganizationCustomer;
};
type OrganizationOrdersEndpoints = Endpoint<"GET", "/organizations/@:organizationSlug/orders", ArrayResult<OrganizationOrder>, ArrayOptions<OrganizationOrder>> | Endpoint<"GET", "/organizations/@:organizationSlug/orders/:orderId", OrganizationOrder> | Endpoint<"GET", "/organizations/@:organizationSlug/events/:eventSlug/orders", ArrayResult<OrganizationOrder>, ArrayOptions<OrganizationOrder>>;

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;
declare enum OrganizationFileType {
    Avatar = "avatar",
    Banner = "banner"
}
type OrganizationEndpoints = Endpoint<"GET", "/organizations/search", Organization[], {
    q: string;
    limit?: number;
}> | Endpoint<"GET", "/organizations", ArrayResult<Organization>, ArrayOptions<Organization>> | Endpoint<"GET", "/organizations/@:organizationSlug", Organization> | Endpoint<"POST", "/organizations", Organization, CreateOrganizationDto> | Endpoint<"PUT", "/organizations/@:organizationSlug", Organization, UpdateOrganizationDto> | Endpoint<"DELETE", "/organizations/@:organizationSlug", Organization, null> | Endpoint<"POST", "/organizations/@:organizationSlug/files/:organizationFileType", string, FormData> | Endpoint<"GET", "/organizations/@:organizationSlug/billing/account", OrganizationBillingAccount> | Endpoint<"GET", "/organizations/@:organizationSlug/billing/link", void> | Endpoint<"GET", "/organizations/@:organizationSlug/billing/dashboard", void> | OrganizationEventEndpoints | OrganizationMembersEndpoints | OrganizationAnalyticsEndpoints | OrganizationCustomersEndpoints | OrganizationOrdersEndpoints;

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

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

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

type SuccessfulAPIResponse<T> = {
    success: true;
    data: T;
};
type ErroredAPIResponse = {
    success: false;
    message: string;
    statusCode: number;
    errors?: {
        [key: string]: string[];
    };
};
type APIResponse<T> = SuccessfulAPIResponse<T> | ErroredAPIResponse;
type PromisedAPIResponse<T> = Promise<APIResponse<T>>;
type PathsFor<M extends Options["method"]> = Extract<Endpoints, {
    method: M;
}>["path"];
type ResponseFor<M extends Options["method"], P extends PathsFor<M>> = Extract<Endpoints, {
    method: M;
    path: P;
}>["res"];
type Response<M extends Options["method"], P extends PathsFor<M>> = APIResponse<Extract<Endpoints, {
    method: M;
    path: P;
}>["res"]>;
type PromisedResponse<M extends Options["method"], P extends PathsFor<M>> = PromisedAPIResponse<Extract<Endpoints, {
    method: M;
    path: P;
}>["res"]>;
type Body<M extends Options["method"], P extends PathsFor<M>> = Extract<Endpoints, {
    method: M;
    path: P;
}>["body"];
type StringifiedQueryValue = string | string[];
type StringifiedQuery<T> = {
    [K in keyof T]: StringifiedQueryValue;
};
type QueryParams<M extends Options["method"], P extends PathsFor<M>>