@impulsedev/chameleon 1.1.0

package/dist/index.d.ts

@@ -0,0 +1,2797 @@
+interface Emoji {
+    id: string | null;
+    name: string | null;
+    roles?: string[];
+    user?: User;
+    requireColons?: boolean;
+    managed?: boolean;
+    animated?: boolean;
+    available?: boolean;
+}
+declare const StickerType: {
+    readonly STANDARD: 1;
+    readonly GUILD: 2;
+};
+declare const StickerFormatType: {
+    readonly PNG: 1;
+    readonly APNG: 2;
+    readonly LOTTIE: 3;
+    readonly GIF: 4;
+};
+interface Sticker {
+    id: string;
+    packId?: string;
+    name: string;
+    description: string | null;
+    tags: string;
+    type: number;
+    formatType: number;
+    available?: boolean;
+    guildId?: string;
+    user?: User;
+    sortValue?: number;
+}
+interface StickerItem {
+    id: string;
+    name: string;
+    formatType: number;
+}
+interface StickerPack {
+    id: string;
+    stickers: Sticker[];
+    name: string;
+    skuId: string;
+    coverStickerId?: string;
+    description: string;
+    bannerAssetId?: string;
+}
+
+interface WelcomeScreenChannel {
+    channelId: string;
+    description: string;
+    emojiId: string | null;
+    emojiName: string | null;
+}
+interface WelcomeScreen {
+    description: string | null;
+    welcomeChannels: WelcomeScreenChannel[];
+}
+interface IncidentsData {
+    invitesDisabledUntil: string | null;
+    dmsDisabledUntil: string | null;
+    dmSpamDetectedAt?: string | null;
+    raidDetectedAt?: string | null;
+}
+interface Guild {
+    id: string;
+    name: string;
+    icon: string | null;
+    iconHash?: string | null;
+    splash: string | null;
+    discoverySplash: string | null;
+    owner?: boolean | null;
+    ownerId: string;
+    permissions?: string | null;
+    region?: string | null;
+    afkChannelId: string | null;
+    afkTimeout: number;
+    widgetEnabled?: boolean;
+    widgetChannelId?: string | null;
+    verificationLevel: number;
+    defaultMessageNotifications: number;
+    explicitContentFilter: number;
+    roles: Role[];
+    emojis: Emoji[];
+    features: string[];
+    mfaLevel: number;
+    applicationId: string | null;
+    systemChannelId: string | null;
+    systemChannelFlags: number;
+    rulesChannelId: string | null;
+    maxPresences?: number | null;
+    maxMembers?: number;
+    vanityUrlCode: string | null;
+    description: string | null;
+    banner: string | null;
+    premiumTier: number;
+    premiumSubscriptionCount?: number;
+    preferredLocale: string;
+    publicUpdatesChannelId: string | null;
+    maxVideoChannelUsers?: number;
+    maxStageVideoChannelUsers?: number;
+    approximateMemberCount?: number;
+    approximatePresenceCount?: number;
+    welcomeScreen?: WelcomeScreen;
+    nsfwLevel: number;
+    stickers?: Sticker[];
+    premiumProgressBarEnabled: boolean;
+    safetyAlertsChannelId?: string | null;
+    incidentsData?: IncidentsData | null;
+    large?: boolean;
+}
+interface Member {
+    user?: User;
+    nick?: string | null;
+    avatar?: string | null;
+    banner?: string | null;
+    roles: string[];
+    joinedAt: number | null;
+    premiumSince?: number | null;
+    deaf: boolean;
+    mute: boolean;
+    flags: number;
+    pending?: boolean;
+    permissions?: string;
+    communicationDisabledUntil?: number | null;
+    avatarDecorationData?: AvatarDecorationData | null;
+    collectibles?: Collectibles | null;
+}
+interface Role {
+    id: string;
+    name: string;
+    color: number;
+    hoist: boolean;
+    icon?: string | null;
+    unicodeEmoji?: string | null;
+    position: number;
+    permissions: string;
+    managed: boolean;
+    mentionable: boolean;
+    tags?: RoleTags;
+    flags: number;
+}
+interface RoleTags {
+    botId?: string;
+    integrationId?: string;
+    premiumSubscriber?: null;
+    subscriptionListingId?: string;
+    availableForPurchase?: null;
+    guildConnections?: null;
+}
+declare const DefaultMessageNotificationLevel: {
+    readonly ALL_MESSAGES: 0;
+    readonly ONLY_MENTIONS: 1;
+};
+declare const ExplicitContentFilterLevel: {
+    readonly DISABLED: 0;
+    readonly MEMBERS_WITHOUT_ROLES: 1;
+    readonly ALL_MEMBERS: 2;
+};
+declare const MFALevel: {
+    readonly NONE: 0;
+    readonly ELEVATED: 1;
+};
+declare const VerificationLevel: {
+    readonly NONE: 0;
+    readonly LOW: 1;
+    readonly MEDIUM: 2;
+    readonly HIGH: 3;
+    readonly VERY_HIGH: 4;
+};
+declare const GuildNSFWLevel: {
+    readonly DEFAULT: 0;
+    readonly EXPLICIT: 1;
+    readonly SAFE: 2;
+    readonly AGE_RESTRICTED: 3;
+};
+declare const PremiumTier: {
+    readonly NONE: 0;
+    readonly TIER_1: 1;
+    readonly TIER_2: 2;
+    readonly TIER_3: 3;
+};
+declare const SystemChannelFlag: {
+    readonly SUPPRESS_JOIN_NOTIFICATIONS: number;
+    readonly SUPPRESS_PREMIUM_SUBSCRIPTIONS: number;
+    readonly SUPPRESS_GUILD_REMINDER_NOTIFICATIONS: number;
+    readonly SUPPRESS_JOIN_NOTIFICATION_REPLIES: number;
+    readonly SUPPRESS_ROLE_SUBSCRIPTION_PURCHASE_NOTIFICATIONS: number;
+    readonly SUPPRESS_ROLE_SUBSCRIPTION_PURCHASE_NOTIFICATION_REPLIES: number;
+};
+declare const GuildMemberFlag: {
+    readonly DID_REJOIN: number;
+    readonly COMPLETED_ONBOARDING: number;
+    readonly BYPASSES_VERIFICATION: number;
+    readonly STARTED_ONBOARDING: number;
+    readonly IS_GUEST: number;
+    readonly STARTED_HOME_ACTIONS: number;
+    readonly COMPLETED_HOME_ACTIONS: number;
+    readonly AUTOMOD_QUARANTINED_USERNAME: number;
+    readonly DM_SETTINGS_UPSELL_ACKNOWLEDGED: number;
+    readonly AUTOMOD_QUARANTINED_GUILD_TAG: number;
+};
+
+declare const ApplicationFlag: {
+    readonly APPLICATION_AUTO_MODERATION_RULE_CREATE_BADGE: number;
+    readonly GATEWAY_PRESENCE: number;
+    readonly GATEWAY_PRESENCE_LIMITED: number;
+    readonly GATEWAY_GUILD_MEMBERS: number;
+    readonly GATEWAY_GUILD_MEMBERS_LIMITED: number;
+    readonly VERIFICATION_PENDING_GUILD_LIMIT: number;
+    readonly EMBEDDED: number;
+    readonly GATEWAY_MESSAGE_CONTENT: number;
+    readonly GATEWAY_MESSAGE_CONTENT_LIMITED: number;
+    readonly APPLICATION_COMMAND_BADGE: number;
+};
+interface TeamMember {
+    membershipState: number;
+    permissions: string[];
+    teamId: string;
+    user: Partial<User>;
+}
+interface Team {
+    icon: string | null;
+    id: string;
+    members: TeamMember[];
+    name: string;
+    ownerUserId: string;
+}
+interface InstallParams {
+    scopes: string[];
+    permissions: string;
+}
+declare const ApplicationIntegrationType: {
+    readonly GUILD_INSTALL: 0;
+    readonly USER_INSTALL: 1;
+};
+interface ApplicationIntegrationTypeConfiguration {
+    oauth2InstallParams?: InstallParams;
+}
+declare const ApplicationEventWebhookStatus: {
+    readonly DISABLED: 1;
+    readonly ENABLED: 2;
+    readonly DISABLED_BY_DISCORD: 3;
+};
+interface Application {
+    id: string;
+    name: string;
+    icon: string | null;
+    description: string;
+    rpcOrigins?: string[];
+    botPublic: boolean;
+    botRequireCodeGrant: boolean;
+    bot?: Partial<User>;
+    termsOfServiceUrl?: string;
+    privacyPolicyUrl?: string;
+    owner?: Partial<User>;
+    verifyKey: string;
+    team: Team | null;
+    guildId?: string;
+    guild?: Partial<Guild>;
+    primarySkuId?: string;
+    slug?: string;
+    coverImage?: string;
+    flags?: number;
+    approximateGuildCount?: number;
+    approximateUserInstallCount?: number;
+    approximateUserAuthorizationCount?: number;
+    redirectUris?: string[];
+    interactionsEndpointUrl?: string | null;
+    roleConnectionsVerificationUrl?: string | null;
+    eventWebhooksUrl?: string | null;
+    eventWebhooksStatus?: number;
+    eventWebhooksTypes?: string[];
+    tags?: string[];
+    installParams?: InstallParams;
+    integrationTypesConfig?: Record<string, ApplicationIntegrationTypeConfiguration>;
+    customInstallUrl?: string;
+}
+declare const ActivityLocationKind: {
+    readonly GUILD_CHANNEL: "gc";
+    readonly PRIVATE_CHANNEL: "pc";
+};
+interface ActivityLocation {
+    id: string;
+    kind: string;
+    channelId: string;
+    guildId?: string;
+}
+interface ActivityInstance {
+    applicationId: string;
+    instanceId: string;
+    launchId: string;
+    location: ActivityLocation;
+    users: string[];
+}
+declare const ApplicationRoleConnectionMetadataType: {
+    readonly INTEGER_LESS_THAN_OR_EQUAL: 1;
+    readonly INTEGER_GREATER_THAN_OR_EQUAL: 2;
+    readonly INTEGER_EQUAL: 3;
+    readonly INTEGER_NOT_EQUAL: 4;
+    readonly DATETIME_LESS_THAN_OR_EQUAL: 5;
+    readonly DATETIME_GREATER_THAN_OR_EQUAL: 6;
+    readonly BOOLEAN_EQUAL: 7;
+    readonly BOOLEAN_NOT_EQUAL: 8;
+};
+interface ApplicationRoleConnectionMetadata {
+    type: number;
+    key: string;
+    name: string;
+    nameLocalizations?: Record<string, string>;
+    description: string;
+    descriptionLocalizations?: Record<string, string>;
+}
+declare const ApplicationCommandType: {
+    readonly CHAT_INPUT: 1;
+    readonly USER: 2;
+    readonly MESSAGE: 3;
+    readonly PRIMARY_ENTRY_POINT: 4;
+};
+declare const ApplicationCommandOptionType: {
+    readonly SUB_COMMAND: 1;
+    readonly SUB_COMMAND_GROUP: 2;
+    readonly STRING: 3;
+    readonly INTEGER: 4;
+    readonly BOOLEAN: 5;
+    readonly USER: 6;
+    readonly CHANNEL: 7;
+    readonly ROLE: 8;
+    readonly MENTIONABLE: 9;
+    readonly NUMBER: 10;
+    readonly ATTACHMENT: 11;
+};
+interface ApplicationCommandOptionChoice {
+    name: string;
+    nameLocalizations?: Record<string, string>;
+    value: string | number;
+}
+interface ApplicationCommandOption {
+    type: number;
+    name: string;
+    nameLocalizations?: Record<string, string>;
+    description: string;
+    descriptionLocalizations?: Record<string, string>;
+    required?: boolean;
+    choices?: ApplicationCommandOptionChoice[];
+    options?: ApplicationCommandOption[];
+    channelTypes?: number[];
+    minValue?: number;
+    maxValue?: number;
+    minLength?: number;
+    maxLength?: number;
+    autocomplete?: boolean;
+}
+interface ApplicationCommand {
+    id: string;
+    type?: number;
+    applicationId: string;
+    guildId?: string;
+    name: string;
+    nameLocalizations?: Record<string, string> | null;
+    description: string;
+    descriptionLocalizations?: Record<string, string> | null;
+    options?: ApplicationCommandOption[];
+    defaultMemberPermissions: string | null;
+    dmPermission?: boolean;
+    defaultPermission?: boolean | null;
+    nsfw?: boolean;
+    version: string;
+    integrationTypes?: number[];
+    contexts?: number[];
+}
+
+declare const IntegrationExpireBehavior: {
+    readonly REMOVE_ROLE: 0;
+    readonly KICK: 1;
+};
+interface IntegrationAccount {
+    id: string;
+    name: string;
+}
+interface Integration {
+    id: string;
+    name: string;
+    type: string;
+    enabled: boolean;
+    syncing?: boolean;
+    roleId?: string;
+    enableEmoticons?: boolean;
+    expireBehavior?: number;
+    expireGracePeriod?: number;
+    user?: User;
+    account: IntegrationAccount;
+    syncedAt?: number;
+    subscriberCount?: number;
+    revoked?: boolean;
+    application?: Application;
+    scopes?: string[];
+}
+
+interface AvatarDecorationData {
+    asset: string;
+    skuId: string;
+}
+interface Nameplate {
+    skuId: string;
+    asset: string;
+    label: string;
+    palette: string;
+}
+interface Collectibles {
+    nameplate?: Nameplate;
+}
+interface UserPrimaryGuild {
+    identityGuildId: string | null;
+    identityEnabled: boolean | null;
+    tag: string | null;
+    badge: string | null;
+}
+interface User {
+    id: string;
+    username: string;
+    discriminator: string;
+    globalName: string | null;
+    avatar: string | null;
+    bot?: boolean;
+    system?: boolean;
+    mfaEnabled?: boolean;
+    banner?: string | null;
+    accentColor?: number | null;
+    locale?: string;
+    verified?: boolean;
+    email?: string | null;
+    flags?: number;
+    premiumType?: number;
+    publicFlags?: number;
+    avatarDecorationData?: AvatarDecorationData | null;
+    collectibles?: Collectibles | null;
+    primaryGuild?: UserPrimaryGuild | null;
+}
+interface Connection {
+    id: string;
+    name: string;
+    type: string;
+    revoked?: boolean;
+    integrations?: Integration[];
+    verified: boolean;
+    friendSync: boolean;
+    showActivity: boolean;
+    twoWayLink: boolean;
+    visibility: number;
+}
+interface ApplicationRoleConnection {
+    platformName?: string | null;
+    metadata: Record<string, string>;
+}
+declare const UserFlag: {
+    readonly STAFF: number;
+    readonly PARTNER: number;
+    readonly HYPESQUAD: number;
+    readonly BUG_HUNTER_LEVEL_1: number;
+    readonly HYPESQUAD_ONLINE_HOUSE_1: number;
+    readonly HYPESQUAD_ONLINE_HOUSE_2: number;
+    readonly HYPESQUAD_ONLINE_HOUSE_3: number;
+    readonly PREMIUM_EARLY_SUPPORTER: number;
+    readonly TEAM_PSEUDO_USER: number;
+    readonly BUG_HUNTER_LEVEL_2: number;
+    readonly VERIFIED_BOT: number;
+    readonly VERIFIED_DEVELOPER: number;
+    readonly CERTIFIED_MODERATOR: number;
+    readonly BOT_HTTP_INTERACTIONS: number;
+};
+declare const PremiumType: {
+    readonly NONE: 0;
+    readonly NITRO_CLASSIC: 1;
+    readonly NITRO: 2;
+    readonly NITRO_BASIC: 3;
+};
+declare const VisibilityType: {
+    readonly NONE: 0;
+    readonly EVERYONE: 1;
+};
+
+interface Channel {
+    id: string;
+    type: number;
+    guildId?: string;
+    position?: number;
+    permissionOverwrites?: Overwrite[];
+    name?: string | null;
+    topic?: string | null;
+    nsfw?: boolean;
+    lastMessageId?: string | null;
+    bitrate?: number;
+    userLimit?: number;
+    rateLimitPerUser?: number;
+    recipients?: User[];
+    icon?: string | null;
+    ownerId?: string;
+    applicationId?: string;
+    managed?: boolean;
+    parentId?: string | null;
+    lastPinTimestamp?: number | null;
+    rtcRegion?: string | null;
+    videoQualityMode?: number;
+    messageCount?: number;
+    memberCount?: number;
+    threadMetadata?: ThreadMetadata;
+    member?: ThreadMember;
+    defaultAutoArchiveDuration?: number;
+    permissions?: string;
+    flags?: number;
+    totalMessageSent?: number;
+    availableTags?: ForumTag[];
+    appliedTags?: string[];
+    defaultReactionEmoji?: DefaultReaction | null;
+    defaultThreadRateLimitPerUser?: number;
+    defaultSortOrder?: number | null;
+    defaultForumLayout?: number;
+}
+interface Overwrite {
+    id: string;
+    type: number;
+    allow: string;
+    deny: string;
+}
+interface ThreadMetadata {
+    archived: boolean;
+    autoArchiveDuration: number;
+    archiveTimestamp: number;
+    locked: boolean;
+    invitable?: boolean;
+    createTimestamp?: number | null;
+}
+interface ThreadMember {
+    id?: string;
+    userId?: string;
+    joinTimestamp: number;
+    flags: number;
+    member?: Member;
+}
+interface DefaultReaction {
+    emojiId: string | null;
+    emojiName: string | null;
+}
+interface ForumTag {
+    id: string;
+    name: string;
+    moderated: boolean;
+    emojiId: string | null;
+    emojiName: string | null;
+}
+declare const ChannelType: {
+    readonly GUILD_TEXT: 0;
+    readonly DM: 1;
+    readonly GUILD_VOICE: 2;
+    readonly GROUP_DM: 3;
+    readonly GUILD_CATEGORY: 4;
+    readonly GUILD_ANNOUNCEMENT: 5;
+    readonly ANNOUNCEMENT_THREAD: 10;
+    readonly PUBLIC_THREAD: 11;
+    readonly PRIVATE_THREAD: 12;
+    readonly GUILD_STAGE_VOICE: 13;
+    readonly GUILD_DIRECTORY: 14;
+    readonly GUILD_FORUM: 15;
+    readonly GUILD_MEDIA: 16;
+};
+declare const VideoQualityMode: {
+    readonly AUTO: 1;
+    readonly FULL: 2;
+};
+declare const ChannelFlag: {
+    readonly PINNED: number;
+    readonly REQUIRE_TAG: number;
+    readonly HIDE_MEDIA_DOWNLOAD_OPTIONS: number;
+};
+declare const SortOrderType: {
+    readonly LATEST_ACTIVITY: 0;
+    readonly CREATION_DATE: 1;
+};
+declare const ForumLayoutType: {
+    readonly NOT_SET: 0;
+    readonly LIST_VIEW: 1;
+    readonly GALLERY_VIEW: 2;
+};
+
+declare const ComponentType: {
+    readonly ACTION_ROW: 1;
+    readonly BUTTON: 2;
+    readonly STRING_SELECT: 3;
+    readonly TEXT_INPUT: 4;
+    readonly USER_SELECT: 5;
+    readonly ROLE_SELECT: 6;
+    readonly MENTIONABLE_SELECT: 7;
+    readonly CHANNEL_SELECT: 8;
+};
+declare const ButtonStyle: {
+    readonly PRIMARY: 1;
+    readonly SECONDARY: 2;
+    readonly SUCCESS: 3;
+    readonly DANGER: 4;
+    readonly LINK: 5;
+    readonly PREMIUM: 6;
+};
+interface SelectOption {
+    label: string;
+    value: string;
+    description?: string;
+    emoji?: Partial<Emoji>;
+    default?: boolean;
+}
+interface MessageComponent {
+    type: number;
+    customId?: string;
+    disabled?: boolean;
+    style?: number;
+    label?: string;
+    emoji?: Partial<Emoji>;
+    url?: string;
+    options?: SelectOption[];
+    placeholder?: string;
+    minValues?: number;
+    maxValues?: number;
+    components?: MessageComponent[];
+    skuId?: string;
+    channelTypes?: number[];
+}
+
+declare const EntitlementType: {
+    readonly PURCHASE: 1;
+    readonly PREMIUM_SUBSCRIPTION: 2;
+    readonly DEVELOPER_GIFT: 3;
+    readonly TEST_MODE_PURCHASE: 4;
+    readonly FREE_PURCHASE: 5;
+    readonly USER_GIFT: 6;
+    readonly PREMIUM_PURCHASE: 7;
+    readonly APPLICATION_SUBSCRIPTION: 8;
+};
+interface Entitlement {
+    id: string;
+    skuId: string;
+    applicationId: string;
+    userId?: string;
+    type: number;
+    deleted: boolean;
+    startsAt?: number | null;
+    endsAt?: number | null;
+    guildId?: string;
+    consumed?: boolean;
+}
+
+interface ResolvedData {
+    users?: Record<string, User>;
+    members?: Record<string, Partial<Member>>;
+    roles?: Record<string, Role>;
+    channels?: Record<string, Partial<Channel>>;
+    messages?: Record<string, Partial<Message>>;
+    attachments?: Record<string, Attachment>;
+}
+interface ApplicationCommandInteractionDataOption {
+    name: string;
+    type: number;
+    value?: string | number | boolean;
+    options?: ApplicationCommandInteractionDataOption[];
+    focused?: boolean;
+}
+interface ApplicationCommandData {
+    id: string;
+    name: string;
+    type: number;
+    resolved?: ResolvedData;
+    options?: ApplicationCommandInteractionDataOption[];
+    guildId?: string;
+    targetId?: string;
+}
+interface MessageComponentData {
+    customId: string;
+    componentType: number;
+    values?: string[];
+    resolved?: ResolvedData;
+}
+interface ModalSubmitData {
+    customId: string;
+    components: MessageComponent[];
+}
+type InteractionData = ApplicationCommandData | MessageComponentData | ModalSubmitData;
+interface Interaction {
+    id: string;
+    applicationId: string;
+    type: number;
+    data?: InteractionData;
+    guild?: Partial<Guild>;
+    guildId?: string;
+    channel?: Partial<Channel>;
+    channelId?: string;
+    member?: Member;
+    user?: User;
+    token: string;
+    version: number;
+    message?: Message;
+    appPermissions?: string;
+    locale?: string;
+    guildLocale?: string;
+    entitlements: Entitlement[];
+    authorizingIntegrationOwners: Record<string, string>;
+    context?: number;
+}
+interface MessageInteraction {
+    id: string;
+    type: number;
+    name: string;
+    user: User;
+    member?: Partial<Member>;
+}
+
+interface ChannelMention {
+    id: string;
+    guildId: string;
+    type: number;
+    name: string;
+}
+interface Attachment {
+    id: string;
+    filename: string;
+    title?: string;
+    description?: string;
+    contentType?: string;
+    size: number;
+    url: string;
+    proxyUrl: string;
+    height?: number | null;
+    width?: number | null;
+    placeholder?: string;
+    placeholderVersion?: number;
+    ephemeral?: boolean;
+    durationSecs?: number;
+    waveform?: string;
+    flags?: number;
+    clipParticipants?: User[];
+    clipCreatedAt?: number;
+    application?: Partial<Application>;
+}
+interface EmbedFooter {
+    text: string;
+    iconUrl?: string;
+    proxyIconUrl?: string;
+}
+interface EmbedImage {
+    url: string;
+    proxyUrl?: string;
+    height?: number;
+    width?: number;
+    contentType?: string;
+    placeholder?: string;
+    placeholderVersion?: number;
+    description?: string;
+    flags?: number;
+}
+interface EmbedVideo {
+    url?: string;
+    proxyUrl?: string;
+    height?: number;
+    width?: number;
+    contentType?: string;
+    placeholder?: string;
+    placeholderVersion?: number;
+    description?: string;
+    flags?: number;
+}
+interface EmbedProvider {
+    name?: string;
+    url?: string;
+}
+interface EmbedAuthor {
+    name: string;
+    url?: string;
+    iconUrl?: string;
+    proxyIconUrl?: string;
+}
+interface EmbedField {
+    name: string;
+    value: string;
+    inline?: boolean;
+}
+interface Embed {
+    title?: string;
+    type?: string;
+    description?: string;
+    url?: string;
+    timestamp?: number;
+    color?: number;
+    footer?: EmbedFooter;
+    image?: EmbedImage;
+    thumbnail?: EmbedImage;
+    video?: EmbedVideo;
+    provider?: EmbedProvider;
+    author?: EmbedAuthor;
+    fields?: EmbedField[];
+    flags?: number;
+}
+interface ReactionCountDetails {
+    burst: number;
+    normal: number;
+}
+interface Reaction {
+    count: number;
+    countDetails: ReactionCountDetails;
+    me: boolean;
+    meBurst: boolean;
+    emoji: Emoji;
+    burstColors: string[];
+}
+interface MessageActivity {
+    type: number;
+    partyId?: string;
+}
+interface MessageReference {
+    type?: number;
+    messageId?: string;
+    channelId?: string;
+    guildId?: string;
+    failIfNotExists?: boolean;
+}
+interface MessageInteractionMetadata {
+    id: string;
+    type: number;
+    user: User;
+    authorizingIntegrationOwners: Record<string, string>;
+    originalResponseMessageId?: string;
+    targetUser?: User;
+    targetMessageId?: string;
+    interactedMessageId?: string;
+    triggeringInteractionMetadata?: MessageInteractionMetadata;
+}
+interface RoleSubscriptionData {
+    roleSubscriptionListingId: string;
+    tierName: string;
+    totalMonthsSubscribed: number;
+    isRenewal: boolean;
+}
+interface MessageCall {
+    participants: string[];
+    endedTimestamp?: number | null;
+}
+interface SharedClientTheme {
+    colors: string[];
+    gradientAngle: number;
+    baseMix: number;
+    baseTheme?: number;
+}
+interface PollMedia {
+    text?: string;
+    emoji?: Partial<Emoji>;
+}
+interface PollAnswer {
+    answerId: number;
+    pollMedia: PollMedia;
+}
+interface PollAnswerCount {
+    id: number;
+    count: number;
+    meVoted: boolean;
+}
+interface PollResults {
+    isFinalized: boolean;
+    answerCounts: PollAnswerCount[];
+}
+interface Poll {
+    question: PollMedia;
+    answers: PollAnswer[];
+    expiry: number | null;
+    allowMultiselect: boolean;
+    layoutType: number;
+    results?: PollResults;
+}
+interface PollCreateRequest {
+    question: PollMedia;
+    answers: PollAnswer[];
+    duration?: number;
+    allowMultiselect?: boolean;
+    layoutType?: number;
+}
+interface MessageSnapshot {
+    message: Partial<Message>;
+}
+interface Message {
+    id: string;
+    channelId: string;
+    guildId?: string;
+    author: User;
+    member?: Member;
+    content: string;
+    url: string;
+    timestamp: number;
+    editedTimestamp: number | null;
+    tts: boolean;
+    mentionEveryone: boolean;
+    mentions: User[];
+    mentionRoles: string[];
+    mentionChannels?: ChannelMention[];
+    attachments: Attachment[];
+    embeds: Embed[];
+    reactions?: Reaction[];
+    nonce?: string | number;
+    pinned: boolean;
+    webhookId?: string;
+    type: number;
+    activity?: MessageActivity;
+    application?: Partial<Application>;
+    applicationId?: string;
+    flags?: number;
+    messageReference?: MessageReference;
+    messageSnapshots?: MessageSnapshot[];
+    referencedMessage?: Message | null;
+    interactionMetadata?: MessageInteractionMetadata;
+    interaction?: MessageInteraction;
+    thread?: Channel;
+    components?: MessageComponent[];
+    stickerItems?: StickerItem[];
+    stickers?: Sticker[];
+    position?: number;
+    roleSubscriptionData?: RoleSubscriptionData;
+    resolved?: ResolvedData;
+    poll?: Poll;
+    call?: MessageCall;
+    sharedClientTheme?: SharedClientTheme;
+}
+declare const MessageType: {
+    readonly DEFAULT: 0;
+    readonly RECIPIENT_ADD: 1;
+    readonly RECIPIENT_REMOVE: 2;
+    readonly CALL: 3;
+    readonly CHANNEL_NAME_CHANGE: 4;
+    readonly CHANNEL_ICON_CHANGE: 5;
+    readonly CHANNEL_PINNED_MESSAGE: 6;
+    readonly USER_JOIN: 7;
+    readonly GUILD_BOOST: 8;
+    readonly GUILD_BOOST_TIER_1: 9;
+    readonly GUILD_BOOST_TIER_2: 10;
+    readonly GUILD_BOOST_TIER_3: 11;
+    readonly CHANNEL_FOLLOW_ADD: 12;
+    readonly GUILD_DISCOVERY_DISQUALIFIED: 14;
+    readonly GUILD_DISCOVERY_REQUALIFIED: 15;
+    readonly GUILD_DISCOVERY_GRACE_PERIOD_INITIAL_WARNING: 16;
+    readonly GUILD_DISCOVERY_GRACE_PERIOD_FINAL_WARNING: 17;
+    readonly THREAD_CREATED: 18;
+    readonly REPLY: 19;
+    readonly CHAT_INPUT_COMMAND: 20;
+    readonly THREAD_STARTER_MESSAGE: 21;
+    readonly GUILD_INVITE_REMINDER: 22;
+    readonly CONTEXT_MENU_COMMAND: 23;
+    readonly AUTO_MODERATION_ACTION: 24;
+    readonly ROLE_SUBSCRIPTION_PURCHASE: 25;
+    readonly INTERACTION_PREMIUM_UPSELL: 26;
+    readonly STAGE_START: 27;
+    readonly STAGE_END: 28;
+    readonly STAGE_SPEAKER: 29;
+    readonly STAGE_TOPIC: 31;
+    readonly GUILD_APPLICATION_PREMIUM_SUBSCRIPTION: 32;
+    readonly GUILD_INCIDENT_ALERT_MODE_ENABLED: 36;
+    readonly GUILD_INCIDENT_ALERT_MODE_DISABLED: 37;
+    readonly GUILD_INCIDENT_REPORT_RAID: 38;
+    readonly GUILD_INCIDENT_REPORT_FALSE_ALARM: 39;
+    readonly PURCHASE_NOTIFICATION: 44;
+    readonly POLL_RESULT: 46;
+};
+declare const MessageActivityType: {
+    readonly JOIN: 1;
+    readonly SPECTATE: 2;
+    readonly LISTEN: 3;
+    readonly JOIN_REQUEST: 5;
+};
+declare const MessageFlag: {
+    readonly CROSSPOSTED: number;
+    readonly IS_CROSSPOST: number;
+    readonly SUPPRESS_EMBEDS: number;
+    readonly SOURCE_MESSAGE_DELETED: number;
+    readonly URGENT: number;
+    readonly HAS_THREAD: number;
+    readonly EPHEMERAL: number;
+    readonly LOADING: number;
+    readonly FAILED_TO_MENTION_SOME_ROLES_IN_THREAD: number;
+    readonly SUPPRESS_NOTIFICATIONS: number;
+    readonly IS_VOICE_MESSAGE: number;
+    readonly HAS_SNAPSHOT: number;
+    readonly IS_COMPONENTS_V2: number;
+};
+declare const MessageReferenceType: {
+    readonly DEFAULT: 0;
+    readonly FORWARD: 1;
+};
+declare const EmbedType: {
+    readonly RICH: "rich";
+    readonly IMAGE: "image";
+    readonly VIDEO: "video";
+    readonly GIFV: "gifv";
+    readonly ARTICLE: "article";
+    readonly LINK: "link";
+    readonly POLL_RESULT: "poll_result";
+};
+declare const AttachmentFlag: {
+    readonly IS_CLIP: number;
+    readonly IS_THUMBNAIL: number;
+    readonly IS_REMIX: number;
+    readonly IS_SPOILER: number;
+    readonly IS_ANIMATED: number;
+};
+
+declare const GuildScheduledEventPrivacyLevel: {
+    readonly GUILD_ONLY: 2;
+};
+declare const GuildScheduledEventStatus: {
+    readonly SCHEDULED: 1;
+    readonly ACTIVE: 2;
+    readonly COMPLETED: 3;
+    readonly CANCELED: 4;
+};
+declare const GuildScheduledEventEntityType: {
+    readonly STAGE_INSTANCE: 1;
+    readonly VOICE: 2;
+    readonly EXTERNAL: 3;
+};
+interface GuildScheduledEventEntityMetadata {
+    location?: string;
+}
+interface GuildScheduledEvent {
+    id: string;
+    guildId: string;
+    channelId: string | null;
+    creatorId?: string | null;
+    name: string;
+    description?: string | null;
+    scheduledStartTime: number;
+    scheduledEndTime: number | null;
+    privacyLevel: number;
+    status: number;
+    entityType: number;
+    entityId: string | null;
+    entityMetadata: GuildScheduledEventEntityMetadata | null;
+    creator?: User;
+    userCount?: number;
+    image?: string | null;
+}
+
+declare const WebhookType: {
+    readonly INCOMING: 1;
+    readonly CHANNEL_FOLLOWER: 2;
+    readonly APPLICATION: 3;
+};
+interface Webhook {
+    id: string;
+    type: number;
+    guildId?: string;
+    channelId?: string | null;
+    user?: User;
+    name: string | null;
+    avatar: string | null;
+    token?: string;
+    applicationId: string | null;
+    sourceGuild?: Partial<Guild>;
+    sourceChannel?: Partial<Channel>;
+    url?: string;
+}
+
+declare const IntentBits: {
+    readonly Guilds: number;
+    readonly GuildMembers: number;
+    readonly GuildModeration: number;
+    readonly GuildEmojisAndStickers: number;
+    readonly GuildIntegrations: number;
+    readonly GuildWebhooks: number;
+    readonly GuildInvites: number;
+    readonly GuildVoiceStates: number;
+    readonly GuildPresences: number;
+    readonly GuildMessages: number;
+    readonly GuildMessageReactions: number;
+    readonly GuildMessageTyping: number;
+    readonly DirectMessages: number;
+    readonly DirectMessageReactions: number;
+    readonly DirectMessageTyping: number;
+    readonly MessageContent: number;
+    readonly GuildScheduledEvents: number;
+    readonly AutoModerationConfiguration: number;
+    readonly AutoModerationExecution: number;
+    readonly GuildMessagePolls: number;
+    readonly DirectMessagePolls: number;
+};
+declare const Intents: {
+    readonly Moderation: readonly [number, number, number];
+    readonly Guilds: number;
+    readonly GuildMembers: number;
+    readonly GuildModeration: number;
+    readonly GuildEmojisAndStickers: number;
+    readonly GuildIntegrations: number;
+    readonly GuildWebhooks: number;
+    readonly GuildInvites: number;
+    readonly GuildVoiceStates: number;
+    readonly GuildPresences: number;
+    readonly GuildMessages: number;
+    readonly GuildMessageReactions: number;
+    readonly GuildMessageTyping: number;
+    readonly DirectMessages: number;
+    readonly DirectMessageReactions: number;
+    readonly DirectMessageTyping: number;
+    readonly MessageContent: number;
+    readonly GuildScheduledEvents: number;
+    readonly AutoModerationConfiguration: number;
+    readonly AutoModerationExecution: number;
+    readonly GuildMessagePolls: number;
+    readonly DirectMessagePolls: number;
+};
+type IntentString = keyof typeof IntentBits;
+type IntentResolvable = IntentString | number | IntentResolvable[] | readonly IntentResolvable[];
+declare enum DISCORD_GATEWAY_OPCODES {
+    DISPATCH = 0,
+    HEARTBEAT = 1,
+    IDENTIFY = 2,
+    PRESENCE_UPDATE = 3,
+    VOICE_STATE_UPDATE = 4,
+    RESUME = 6,
+    RECONNECT = 7,
+    REQUEST_GUILD_MEMBERS = 8,
+    INVALID_SESSION = 9,
+    HELLO = 10,
+    HEARTBEAT_ACK = 11,
+    REQUEST_SOUNDBOARD_SOUNDS = 31,
+    REQUEST_CHANNEL_INFO = 43
+}
+declare const DISCORD_PERMISSIONS: {
+    readonly CREATE_INSTANT_INVITE: bigint;
+    readonly KICK_MEMBERS: bigint;
+    readonly BAN_MEMBERS: bigint;
+    readonly ADMINISTRATOR: bigint;
+    readonly MANAGE_CHANNELS: bigint;
+    readonly MANAGE_GUILD: bigint;
+    readonly ADD_REACTIONS: bigint;
+    readonly VIEW_AUDIT_LOG: bigint;
+    readonly PRIORITY_SPEAKER: bigint;
+    readonly STREAM: bigint;
+    readonly VIEW_CHANNEL: bigint;
+    readonly SEND_MESSAGES: bigint;
+    readonly SEND_TTS_MESSAGES: bigint;
+    readonly MANAGE_MESSAGES: bigint;
+    readonly EMBED_LINKS: bigint;
+    readonly ATTACH_FILES: bigint;
+    readonly READ_MESSAGE_HISTORY: bigint;
+    readonly MENTION_EVERYONE: bigint;
+    readonly USE_EXTERNAL_EMOJIS: bigint;
+    readonly VIEW_GUILD_INSIGHTS: bigint;
+    readonly CONNECT: bigint;
+    readonly SPEAK: bigint;
+    readonly MUTE_MEMBERS: bigint;
+    readonly DEAFEN_MEMBERS: bigint;
+    readonly MOVE_MEMBERS: bigint;
+    readonly USE_VAD: bigint;
+    readonly CHANGE_NICKNAME: bigint;
+    readonly MANAGE_NICKNAMES: bigint;
+    readonly MANAGE_ROLES: bigint;
+    readonly MANAGE_WEBHOOKS: bigint;
+    readonly MANAGE_GUILD_EXPRESSIONS: bigint;
+    readonly USE_APPLICATION_COMMANDS: bigint;
+    readonly REQUEST_TO_SPEAK: bigint;
+    readonly MANAGE_EVENTS: bigint;
+    readonly MANAGE_THREADS: bigint;
+    readonly CREATE_PUBLIC_THREADS: bigint;
+    readonly CREATE_PRIVATE_THREADS: bigint;
+    readonly USE_EXTERNAL_STICKERS: bigint;
+    readonly SEND_MESSAGES_IN_THREADS: bigint;
+    readonly USE_EMBEDDED_ACTIVITIES: bigint;
+    readonly MODERATE_MEMBERS: bigint;
+    readonly VIEW_CREATOR_MONETIZATION_ANALYTICS: bigint;
+    readonly USE_SOUNDBOARD: bigint;
+    readonly CREATE_GUILD_EXPRESSIONS: bigint;
+    readonly CREATE_EVENTS: bigint;
+    readonly USE_EXTERNAL_SOUNDS: bigint;
+    readonly SEND_VOICE_MESSAGES: bigint;
+    readonly SET_VOICE_CHANNEL_STATUS: bigint;
+    readonly SEND_POLLS: bigint;
+    readonly USE_EXTERNAL_APPS: bigint;
+    readonly PIN_MESSAGES: bigint;
+    readonly BYPASS_SLOWMODE: bigint;
+};
+declare const AUDIT_LOG_EVENT_TYPES: {
+    readonly GUILD_UPDATE: 1;
+    readonly CHANNEL_CREATE: 10;
+    readonly CHANNEL_UPDATE: 11;
+    readonly CHANNEL_DELETE: 12;
+    readonly CHANNEL_OVERWRITE_CREATE: 13;
+    readonly CHANNEL_OVERWRITE_UPDATE: 14;
+    readonly CHANNEL_OVERWRITE_DELETE: 15;
+    readonly MEMBER_KICK: 20;
+    readonly MEMBER_PRUNE: 21;
+    readonly MEMBER_BAN_ADD: 22;
+    readonly MEMBER_BAN_REMOVE: 23;
+    readonly MEMBER_UPDATE: 24;
+    readonly MEMBER_ROLE_UPDATE: 25;
+    readonly MEMBER_MOVE: 26;
+    readonly MEMBER_DISCONNECT: 27;
+    readonly BOT_ADD: 28;
+    readonly ROLE_CREATE: 30;
+    readonly ROLE_UPDATE: 31;
+    readonly ROLE_DELETE: 32;
+    readonly INVITE_CREATE: 40;
+    readonly INVITE_UPDATE: 41;
+    readonly INVITE_DELETE: 42;
+    readonly WEBHOOK_CREATE: 50;
+    readonly WEBHOOK_UPDATE: 51;
+    readonly WEBHOOK_DELETE: 52;
+    readonly EMOJI_CREATE: 60;
+    readonly EMOJI_UPDATE: 61;
+    readonly EMOJI_DELETE: 62;
+    readonly MESSAGE_DELETE: 72;
+    readonly MESSAGE_BULK_DELETE: 73;
+    readonly MESSAGE_PIN: 74;
+    readonly MESSAGE_UNPIN: 75;
+    readonly INTEGRATION_CREATE: 80;
+    readonly INTEGRATION_UPDATE: 81;
+    readonly INTEGRATION_DELETE: 82;
+    readonly STAGE_INSTANCE_CREATE: 83;
+    readonly STAGE_INSTANCE_UPDATE: 84;
+    readonly STAGE_INSTANCE_DELETE: 85;
+    readonly STICKER_CREATE: 90;
+    readonly STICKER_UPDATE: 91;
+    readonly STICKER_DELETE: 92;
+    readonly GUILD_SCHEDULED_EVENT_CREATE: 100;
+    readonly GUILD_SCHEDULED_EVENT_UPDATE: 101;
+    readonly GUILD_SCHEDULED_EVENT_DELETE: 102;
+    readonly THREAD_CREATE: 110;
+    readonly THREAD_UPDATE: 111;
+    readonly THREAD_DELETE: 112;
+    readonly APPLICATION_COMMAND_PERMISSION_UPDATE: 121;
+    readonly SOUNDBOARD_SOUND_CREATE: 130;
+    readonly SOUNDBOARD_SOUND_UPDATE: 131;
+    readonly SOUNDBOARD_SOUND_DELETE: 132;
+    readonly AUTO_MODERATION_RULE_CREATE: 140;
+    readonly AUTO_MODERATION_RULE_UPDATE: 141;
+    readonly AUTO_MODERATION_RULE_DELETE: 142;
+    readonly AUTO_MODERATION_BLOCK_MESSAGE: 143;
+    readonly AUTO_MODERATION_FLAG_TO_CHANNEL: 144;
+    readonly AUTO_MODERATION_USER_COMMUNICATION_DISABLED: 145;
+    readonly AUTO_MODERATION_QUARANTINE_USER: 146;
+    readonly CREATOR_MONETIZATION_REQUEST_CREATED: 150;
+    readonly CREATOR_MONETIZATION_TERMS_ACCEPTED: 151;
+    readonly ONBOARDING_PROMPT_CREATE: 163;
+    readonly ONBOARDING_PROMPT_UPDATE: 164;
+    readonly ONBOARDING_PROMPT_DELETE: 165;
+    readonly ONBOARDING_CREATE: 166;
+    readonly ONBOARDING_UPDATE: 167;
+    readonly HOME_SETTINGS_CREATE: 190;
+    readonly HOME_SETTINGS_UPDATE: 191;
+    readonly VOICE_CHANNEL_STATUS_UPDATE: 192;
+    readonly VOICE_CHANNEL_STATUS_DELETE: 193;
+};
+declare enum Activity {
+    PLAYING = 0,
+    STREAMING = 1,
+    LISTENING = 2,
+    WATCHING = 3,
+    CUSTOM = 4,
+    COMPETING = 5
+}
+
+declare const AutoModerationEventType: {
+    readonly MESSAGE_SEND: 1;
+    readonly MEMBER_UPDATE: 2;
+};
+declare const AutoModerationTriggerType: {
+    readonly KEYWORD: 1;
+    readonly SPAM: 3;
+    readonly KEYWORD_PRESET: 4;
+    readonly MENTION_SPAM: 5;
+    readonly MEMBER_PROFILE: 6;
+};
+declare const AutoModerationKeywordPresetType: {
+    readonly PROFANITY: 1;
+    readonly SEXUAL_CONTENT: 2;
+    readonly SLURS: 3;
+};
+declare const AutoModerationActionType: {
+    readonly BLOCK_MESSAGE: 1;
+    readonly SEND_ALERT_MESSAGE: 2;
+    readonly TIMEOUT: 3;
+    readonly BLOCK_MEMBER_INTERACTION: 4;
+};
+interface AutoModerationTriggerMetadata {
+    keywordFilter?: string[];
+    regexPatterns?: string[];
+    presets?: number[];
+    allowList?: string[];
+    mentionTotalLimit?: number;
+    mentionRaidProtectionEnabled?: boolean;
+}
+interface AutoModerationActionMetadata {
+    channelId?: string;
+    durationSeconds?: number;
+    customMessage?: string;
+}
+interface AutoModerationAction {
+    type: number;
+    metadata?: AutoModerationActionMetadata;
+}
+interface AutoModerationRule {
+    id: string;
+    guildId: string;
+    name: string;
+    creatorId: string;
+    eventType: number;
+    triggerType: number;
+    triggerMetadata: AutoModerationTriggerMetadata;
+    actions: AutoModerationAction[];
+    enabled: boolean;
+    exemptRoles: string[];
+    exemptChannels: string[];
+}
+
+interface AuditLogChange {
+    newValue?: unknown;
+    oldValue?: unknown;
+    key: string;
+}
+interface OptionalAuditEntryInfo {
+    applicationId?: string;
+    autoModerationRuleName?: string;
+    autoModerationRuleTriggerType?: string;
+    channelId?: string;
+    count?: string;
+    deleteMemberDays?: string;
+    id?: string;
+    membersRemoved?: string;
+    messageId?: string;
+    roleName?: string;
+    type?: string;
+    integrationType?: string;
+    status?: string;
+}
+interface AuditLogEntry {
+    targetId: string | null;
+    changes?: AuditLogChange[];
+    userId: string | null;
+    id: string;
+    actionType: (typeof AUDIT_LOG_EVENT_TYPES)[keyof typeof AUDIT_LOG_EVENT_TYPES];
+    options?: OptionalAuditEntryInfo;
+    reason?: string;
+}
+interface AuditLog {
+    applicationCommands: Partial<ApplicationCommand>[];
+    auditLogEntries: AuditLogEntry[];
+    autoModerationRules: AutoModerationRule[];
+    guildScheduledEvents: GuildScheduledEvent[];
+    integrations: Partial<Integration>[];
+    threads: Channel[];
+    users: User[];
+    webhooks: Webhook[];
+}
+
+declare const InviteType: {
+    readonly GUILD: 0;
+    readonly GROUP_DM: 1;
+    readonly FRIEND: 2;
+};
+declare const InviteTargetType: {
+    readonly STREAM: 1;
+    readonly EMBEDDED_APPLICATION: 2;
+};
+declare const GuildInviteFlag: {
+    readonly IS_GUEST_INVITE: number;
+};
+interface Invite {
+    type: number;
+    code: string;
+    guild?: Partial<Guild>;
+    channel: Partial<Channel> | null;
+    inviter?: User;
+    targetType?: number;
+    targetUser?: User;
+    targetApplication?: Partial<Application>;
+    approximatePresenceCount?: number;
+    approximateMemberCount?: number;
+    expiresAt: number | null;
+    guildScheduledEvent?: GuildScheduledEvent;
+    flags?: number;
+    roles?: Partial<{
+        id: string;
+        name: string;
+        position: number;
+        color: number;
+        icon: string | null;
+        unicodeEmoji: string | null;
+    }>[];
+}
+interface InviteMetadata {
+    uses: number;
+    maxUses: number;
+    maxAge: number;
+    temporary: boolean;
+    createdAt: number;
+}
+interface InviteStageInstance {
+    members: Partial<Member>[];
+    participantCount: number;
+    speakerCount: number;
+    topic: string;
+}
+
+declare const LobbyMemberFlag: {
+    readonly CAN_LINK_LOBBY: number;
+};
+interface LobbyMember {
+    id: string;
+    metadata?: Record<string, string> | null;
+    flags?: number;
+}
+interface Lobby {
+    id: string;
+    applicationId: string;
+    metadata: Record<string, string> | null;
+    members: LobbyMember[];
+    linkedChannel?: Channel;
+}
+
+declare const SkuType: {
+    readonly DURABLE: 2;
+    readonly CONSUMABLE: 3;
+    readonly SUBSCRIPTION: 5;
+    readonly SUBSCRIPTION_GROUP: 6;
+};
+declare const SkuFlag: {
+    readonly AVAILABLE: number;
+    readonly GUILD_SUBSCRIPTION: number;
+    readonly USER_SUBSCRIPTION: number;
+};
+interface Sku {
+    id: string;
+    type: number;
+    applicationId: string;
+    name: string;
+    slug: string;
+    flags: number;
+}
+
+interface SoundboardSound {
+    name: string;
+    soundId: string;
+    volume: number;
+    emojiId: string | null;
+    emojiName: string | null;
+    guildId?: string;
+    available: boolean;
+    user?: User;
+}
+
+declare const StagePrivacyLevel: {
+    readonly PUBLIC: 1;
+    readonly GUILD_ONLY: 2;
+};
+interface StageInstance {
+    id: string;
+    guildId: string;
+    channelId: string;
+    topic: string;
+    privacyLevel: number;
+    discoverableDisabled: boolean;
+    guildScheduledEventId: string | null;
+}
+
+declare const SubscriptionStatus: {
+    readonly ACTIVE: 0;
+    readonly ENDING: 1;
+    readonly INACTIVE: 2;
+};
+interface Subscription {
+    id: string;
+    userId: string;
+    skuIds: string[];
+    entitlementIds: string[];
+    renewalSkuIds: string[] | null;
+    currentPeriodStart: number;
+    currentPeriodEnd: number;
+    status: number;
+    canceledAt: number | null;
+    country?: string;
+}
+
+interface GuildTemplate {
+    code: string;
+    name: string;
+    description: string | null;
+    usageCount: number;
+    creatorId: string;
+    creator: User;
+    createdAt: number;
+    updatedAt: number;
+    sourceGuildId: string;
+    serializedSourceGuild: Partial<Guild>;
+    isDirty: boolean | null;
+}
+
+interface Voice {
+    guildId?: string;
+    channelId: string;
+    userId: string;
+    member?: Member;
+    sessionId: string;
+    deaf: boolean;
+    mute: boolean;
+    selfDeaf: boolean;
+    selfMute: boolean;
+    selfStream: boolean;
+    selfVideo: boolean;
+    suppress: boolean;
+    requestToSpeakTimestamp: number | null;
+}
+declare const CHAMELEON_SELF_MAP: {
+    readonly selfMute: "userMuted";
+    readonly selfDeaf: "userDeafened";
+    readonly selfStream: "userStreaming";
+    readonly selfVideo: "userVideo";
+};
+type ChameleonSelfKey = typeof CHAMELEON_SELF_MAP[keyof typeof CHAMELEON_SELF_MAP];
+
+/**
+ * Chameleon's internal store structure,
+ * acts as an least recently used cache to optimize memory usage
+ * it's named Tongue because a chameleon catches things with its tongue, you get it right? Right??? RIGHT?!?!?
+ */
+declare class Tongue<K, V> {
+    private map;
+    private max;
+    constructor(maxSize?: number);
+    get(key: K): V | undefined;
+    set(key: K, val: V): this;
+    has(key: K): boolean;
+    delete(key: K): boolean;
+    clear(): void;
+    get size(): number;
+    values(): IterableIterator<V>;
+    keys(): IterableIterator<K>;
+}
+
+interface StoreOptions {
+    messages?: number;
+    users?: number;
+    members?: number;
+    guilds?: number;
+    roles?: number;
+    channels?: number;
+    emojis?: number;
+    stickers?: number;
+    stageInstances?: number;
+    scheduledEvents?: number;
+    autoModRules?: number;
+    integrations?: number;
+}
+declare class TongueStore {
+    guilds: Tongue<string, Guild>;
+    roles: Tongue<string, Role>;
+    channels: Tongue<string, Channel>;
+    users: Tongue<string, User>;
+    members: Tongue<string, Member>;
+    messages: Tongue<string, Message>;
+    emojis: Tongue<string, Emoji>;
+    stickers: Tongue<string, Sticker>;
+    stageInstances: Tongue<string, StageInstance>;
+    scheduledEvents: Tongue<string, GuildScheduledEvent>;
+    autoModRules: Tongue<string, AutoModerationRule>;
+    integrations: Tongue<string, Integration>;
+    constructor(options?: StoreOptions);
+    static memberKey(guildId: string, userId: string): string;
+}
+
+type ChameleonAPIResult<T> = {
+    ok: true;
+    data: T;
+} | {
+    ok: false;
+    status: number;
+    code?: number;
+    message: string;
+    raw?: unknown;
+};
+interface ChameleonRESTOptions {
+    token: string;
+    version?: number;
+}
+type HttpMethod = 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+
+declare class ChameleonREST {
+    readonly token: string;
+    readonly version: number;
+    private readonly baseUrl;
+    private readonly limiter;
+    constructor(options: ChameleonRESTOptions);
+    /**
+     * Internal generic request handler that doesn't throw, returning `{ ok: boolean, ... }` shape
+     */
+    request<T = unknown>(method: HttpMethod, endpoint: string, body?: unknown, headers?: Record<string, string>): Promise<ChameleonAPIResult<T>>;
+    get<T = unknown>(endpoint: string, headers?: Record<string, string>): Promise<ChameleonAPIResult<T>>;
+    post<T = unknown>(endpoint: string, body?: unknown, headers?: Record<string, string>): Promise<ChameleonAPIResult<T>>;
+    put<T = unknown>(endpoint: string, body?: unknown, headers?: Record<string, string>): Promise<ChameleonAPIResult<T>>;
+    patch<T = unknown>(endpoint: string, body?: unknown, headers?: Record<string, string>): Promise<ChameleonAPIResult<T>>;
+    delete<T = unknown>(endpoint: string, headers?: Record<string, string>): Promise<ChameleonAPIResult<T>>;
+}
+
+interface ChameleonGatewayOptions {
+    token: string;
+    intents: number;
+    version?: number;
+    encoding?: 'json' | 'etf';
+    largeThreshold?: number;
+    shard?: [number, number];
+}
+type GatewayPayload<T = unknown> = {
+    op: number;
+    d: T;
+    s?: number | null;
+    t?: string | null;
+};
+type GatewayStatus = 'idle' | 'connecting' | 'connected' | 'resuming' | 'disconnected';
+declare class ChameleonGateway {
+    readonly token: string;
+    readonly intents: number;
+    readonly version: number;
+    ms: number;
+    readonly encoding: string;
+    readonly largeThreshold: number;
+    readonly shard?: [number, number];
+    status: GatewayStatus;
+    private ws;
+    private heartbeatTimer;
+    private heartbeatIntervalMs;
+    private heartbeatAcked;
+    private seq;
+    private sessionId;
+    private baseUrl;
+    private resumeUrl;
+    private reconnectAttempts;
+    private reconnectTimer;
+    private _lastHeartbeatSend;
+    private listeners;
+    constructor(options: ChameleonGatewayOptions);
+    /**
+     * Open a new WebSocket connection to the Gateway,
+     * if resuming, uses the resume_gateway_url, otherwise uses the base URL
+     */
+    connect(): void;
+    /**
+     * Gracefully close the connection
+     * code 1000/1001 invalidates the session
+     * any other code keeps the session alive for resume
+     */
+    disconnect(code?: number, reason?: string): void;
+    /**
+     * Send a payload to the Gateway.
+     */
+    send(op: number, d: unknown): void;
+    pendingPresence: Record<string, any> | null;
+    /**
+     * Update the presence/status for this shard
+     */
+    updatePresence(options: {
+        status?: 'online' | 'dnd' | 'idle' | 'invisible' | 'offline';
+        activities?: Array<{
+            name: string;
+            type: number;
+            url?: string;
+            state?: string;
+        }>;
+        afk?: boolean;
+        since?: number | null;
+    }): void;
+    /**
+     * request offline/large guild members from the Gateway
+     * this is used to lazy-load members into the cache via GUILD_MEMBERS_CHUNK events
+     */
+    requestGuildMembers(options: {
+        guildId: string | string[];
+        query?: string;
+        limit: number;
+        presences?: boolean;
+        userIds?: string | string[];
+        nonce?: string;
+    }): void;
+    /**
+     * Register an event listener.
+     */
+    on<T = unknown>(event: string, listener: (data: T) => void): void;
+    /**
+     * Remove all listeners for a specific event, or all listeners entirely.
+     */
+    removeAllListeners(event?: string): void;
+    private emit;
+    private onOpen;
+    private onMessage;
+    private onClose;
+    private onError;
+    private handleDispatch;
+    /**
+     * Start the heartbeat loop
+     * first heartbeat is sent after interval * jitter
+     * subsequent heartbeats are sent every interval ms
+     */
+    private startHeartbeat;
+    /**
+     * send a single heartbeat, if the previous one was not ACKed,
+     * we close and reconnect
+     */
+    private sendHeartbeat;
+    private stopHeartbeat;
+    private canResume;
+    /**
+     * send Identify or Resume depending on whether we have an active session
+     */
+    private identify;
+    /**
+     * schedule a reconnect with exponential backoff
+     * delay: min(1s * 2^attempt, 30s) + jitter
+     */
+    private scheduleReconnect;
+    private clearReconnectTimer;
+}
+
+type PartialChannel = Partial<Channel> & {
+    id: string;
+};
+type PartialGuild = Partial<Guild> & {
+    id: string;
+};
+type ChameleonEvent = {
+    type: 'READY';
+} | {
+    type: 'RESUMED';
+} | {
+    type: 'GUILD_CREATE';
+    guild: Guild;
+    partial?: boolean;
+} | {
+    type: 'GUILD_AVAILABLE';
+    guild: Guild;
+    reason: 'hydration' | 'outage';
+    partial?: boolean;
+} | {
+    type: 'GUILD_UNAVAILABLE';
+    guildId: string;
+} | {
+    type: 'GUILD_UPDATE';
+    oldGuild?: Guild;
+    guild: Guild;
+} | {
+    type: 'GUILD_DELETE';
+    guildId: string;
+} | {
+    type: 'CHANNEL_CREATE';
+    channel: Channel;
+    guild?: PartialGuild;
+} | {
+    type: 'CHANNEL_UPDATE';
+    oldChannel?: Channel;
+    channel: Channel;
+    guild?: PartialGuild;
+} | {
+    type: 'CHANNEL_DELETE';
+    channelId: string;
+    guild?: PartialGuild;
+} | {
+    type: 'CHANNEL_PINS_UPDATE';
+    channelId: string;
+    guildId?: string;
+    lastPinTimestamp?: number | null;
+} | {
+    type: 'THREAD_CREATE';
+    channel: Channel;
+} | {
+    type: 'THREAD_UPDATE';
+    oldChannel?: Channel;
+    channel: Channel;
+} | {
+    type: 'THREAD_DELETE';
+    id: string;
+    guildId: string;
+    parentId: string;
+    channelType: number;
+} | {
+    type: 'THREAD_LIST_SYNC';
+    guildId: string;
+    channelIds?: string[];
+    threads: Channel[];
+    members: unknown[];
+} | {
+    type: 'GUILD_MEMBER_ADD';
+    member: Member;
+    guildId: string;
+} | {
+    type: 'GUILD_MEMBER_UPDATE';
+    oldMember?: Member;
+    guildId: string;
+    user: User;
+    roles: string[];
+    nick?: string | null;
+    joinedAt?: number | null;
+} | {
+    type: 'GUILD_MEMBER_REMOVE';
+    user: User;
+    guildId: string;
+} | {
+    type: 'GUILD_MEMBERS_CHUNK';
+    guildId: string;
+    members: Member[];
+    chunkIndex: number;
+    chunkCount: number;
+    notFound?: string[];
+    nonce?: string;
+} | {
+    type: 'GUILD_ROLE_CREATE';
+    guildId: string;
+    role: Role;
+} | {
+    type: 'GUILD_ROLE_UPDATE';
+    oldRole?: Role;
+    guildId: string;
+    role: Role;
+} | {
+    type: 'GUILD_ROLE_DELETE';
+    guildId: string;
+    roleId: string;
+} | {
+    type: 'GUILD_BAN_ADD';
+    guildId: string;
+    user: User;
+} | {
+    type: 'GUILD_BAN_REMOVE';
+    guildId: string;
+    user: User;
+} | {
+    type: 'GUILD_EMOJIS_UPDATE';
+    guildId: string;
+    emojis: Emoji[];
+} | {
+    type: 'GUILD_STICKERS_UPDATE';
+    guildId: string;
+    stickers: Sticker[];
+} | {
+    type: 'MESSAGE_CREATE';
+    message: Message;
+    channel: PartialChannel;
+} | {
+    type: 'MESSAGE_UPDATE';
+    oldMessage?: Message;
+    message: Message;
+    channel: PartialChannel;
+} | {
+    type: 'MESSAGE_DELETE';
+    messageId: string;
+    channelId: string;
+    guildId?: string;
+    message?: Message;
+} | {
+    type: 'MESSAGE_DELETE_BULK';
+    messageIds: string[];
+    channelId: string;
+    guildId?: string;
+    messages?: Message[];
+} | {
+    type: 'MESSAGE_REACTION_ADD';
+    userId: string;
+    channelId: string;
+    messageId: string;
+    guildId?: string;
+    emoji: Partial<Emoji>;
+    member?: Member;
+} | {
+    type: 'MESSAGE_REACTION_REMOVE';
+    userId: string;
+    channelId: string;
+    messageId: string;
+    guildId?: string;
+    emoji: Partial<Emoji>;
+} | {
+    type: 'MESSAGE_REACTION_REMOVE_ALL';
+    channelId: string;
+    messageId: string;
+    guildId?: string;
+} | {
+    type: 'MESSAGE_REACTION_REMOVE_EMOJI';
+    channelId: string;
+    messageId: string;
+    guildId?: string;
+    emoji: Partial<Emoji>;
+} | {
+    type: 'INTERACTION_CREATE';
+    interaction: Interaction;
+} | {
+    type: 'VOICE_STATE_UPDATE';
+    voiceState: Voice;
+} | {
+    type: 'VOICE_SERVER_UPDATE';
+    token: string;
+    guildId: string;
+    endpoint: string | null;
+} | {
+    type: 'STAGE_INSTANCE_CREATE';
+    stageInstance: StageInstance;
+} | {
+    type: 'STAGE_INSTANCE_UPDATE';
+    stageInstance: StageInstance;
+} | {
+    type: 'STAGE_INSTANCE_DELETE';
+    stageInstance: StageInstance;
+} | {
+    type: 'GUILD_SOUNDBOARD_SOUND_CREATE';
+    guildId: string;
+    sound: SoundboardSound;
+} | {
+    type: 'GUILD_SOUNDBOARD_SOUND_UPDATE';
+    guildId: string;
+    sound: SoundboardSound;
+} | {
+    type: 'GUILD_SOUNDBOARD_SOUND_DELETE';
+    guildId: string;
+    soundId: string;
+} | {
+    type: 'GUILD_SOUNDBOARD_SOUNDS_UPDATE';
+    guildId: string;
+    sounds: SoundboardSound[];
+} | {
+    type: 'SUBSCRIPTION_CREATE';
+    subscription: Subscription;
+} | {
+    type: 'SUBSCRIPTION_UPDATE';
+    subscription: Subscription;
+} | {
+    type: 'SUBSCRIPTION_DELETE';
+    subscription: Subscription;
+} | {
+    type: 'VOICE_CHANNEL_EFFECT_SEND';
+    channelId: string;
+    guildId: string;
+    userId: string;
+    emoji?: Partial<Emoji>;
+} | {
+    type: 'GUILD_AUDIT_LOG_ENTRY_CREATE';
+    guildId: string;
+    entry: AuditLogEntry;
+} | {
+    type: 'THREAD_MEMBERS_UPDATE';
+    id: string;
+    guildId: string;
+    memberCount: number;
+    addedMembers?: Partial<Member>[];
+    removedMemberIds?: string[];
+} | {
+    type: 'THREAD_MEMBER_UPDATE';
+    member: Partial<Member>;
+    guildId: string;
+} | {
+    type: 'APPLICATION_COMMAND_PERMISSIONS_UPDATE';
+    permissions: {
+        applicationId: string;
+        guildId: string;
+        id: string;
+        permissions: string[];
+    }[];
+} | {
+    type: 'GUILD_SCHEDULED_EVENT_CREATE';
+    scheduledEvent: GuildScheduledEvent;
+} | {
+    type: 'GUILD_SCHEDULED_EVENT_UPDATE';
+    scheduledEvent: GuildScheduledEvent;
+} | {
+    type: 'GUILD_SCHEDULED_EVENT_DELETE';
+    scheduledEvent: GuildScheduledEvent;
+} | {
+    type: 'GUILD_SCHEDULED_EVENT_USER_ADD';
+    guildScheduledEventId: string;
+    userId: string;
+    guildId: string;
+} | {
+    type: 'GUILD_SCHEDULED_EVENT_USER_REMOVE';
+    guildScheduledEventId: string;
+    userId: string;
+    guildId: string;
+} | {
+    type: 'AUTO_MODERATION_RULE_CREATE';
+    rule: AutoModerationRule;
+} | {
+    type: 'AUTO_MODERATION_RULE_UPDATE';
+    rule: AutoModerationRule;
+} | {
+    type: 'AUTO_MODERATION_RULE_DELETE';
+    rule: AutoModerationRule;
+} | {
+    type: 'AUTO_MODERATION_ACTION_EXECUTION';
+    guildId: string;
+    action: AutoModerationAction;
+    ruleId: string;
+    ruleTriggerType: number;
+    userId: string;
+    channelId?: string;
+    messageId?: string;
+    content?: string;
+    matchedKeyword?: string | null;
+    matchedContent?: string | null;
+} | {
+    type: 'INVITE_CREATE';
+    channelId: string;
+    code: string;
+    guildId?: string;
+    inviter?: User;
+    maxAge: number;
+    maxUses: number;
+    temporary: boolean;
+} | {
+    type: 'INVITE_DELETE';
+    channelId: string;
+    code: string;
+    guildId?: string;
+} | {
+    type: 'GUILD_INTEGRATIONS_UPDATE';
+    guildId: string;
+} | {
+    type: 'INTEGRATION_CREATE';
+    guildId: string;
+    integration: Integration;
+} | {
+    type: 'INTEGRATION_UPDATE';
+    guildId: string;
+    integration: Integration;
+} | {
+    type: 'INTEGRATION_DELETE';
+    id: string;
+    guildId: string;
+    applicationId?: string;
+} | {
+    type: 'ENTITLEMENT_CREATE';
+    entitlement: Entitlement;
+} | {
+    type: 'ENTITLEMENT_UPDATE';
+    entitlement: Entitlement;
+} | {
+    type: 'ENTITLEMENT_DELETE';
+    entitlement: Entitlement;
+} | {
+    type: 'PRESENCE_UPDATE';
+    user: Partial<User> & {
+        id: string;
+    };
+    guildId: string;
+    status: string;
+    activities: unknown[];
+    clientStatus: unknown;
+} | {
+    type: 'TYPING_START';
+    channelId: string;
+    guildId?: string;
+    userId: string;
+    timestamp: number;
+    member?: Member;
+} | {
+    type: 'USER_UPDATE';
+    oldUser?: User;
+    user: User;
+} | {
+    type: 'WEBHOOKS_UPDATE';
+    guildId: string;
+    channelId: string;
+} | {
+    type: 'MESSAGE_POLL_VOTE_ADD';
+    userId: string;
+    channelId: string;
+    messageId: string;
+    guildId?: string;
+    answerId: number;
+} | {
+    type: 'MESSAGE_POLL_VOTE_REMOVE';
+    userId: string;
+    channelId: string;
+    messageId: string;
+    guildId?: string;
+    answerId: number;
+};
+type ChameleonEventHandler = (event: ChameleonEvent) => void | Promise<void>;
+
+type OptionType = 'string' | 'integer' | 'boolean' | 'user' | 'channel' | 'role' | 'number';
+interface OptionDef<T extends OptionType, R extends boolean> {
+    type: T;
+    description: string;
+    required: R;
+    min?: number;
+    max?: number;
+    choices?: {
+        name: string;
+        value: string | number;
+    }[];
+}
+type ResolveOptionType<T extends OptionType> = T extends 'string' ? string : T extends 'integer' | 'number' ? number : T extends 'boolean' ? boolean : T extends 'user' ? User : T extends 'channel' ? Channel : T extends 'role' ? Role : never;
+type ResolveOption<O extends OptionDef<any, boolean>> = O['required'] extends true ? ResolveOptionType<O['type']> : ResolveOptionType<O['type']> | undefined;
+type ResolveOptions<O extends Record<string, OptionDef<any, boolean>>> = {
+    [K in keyof O]: ResolveOption<O[K]>;
+};
+declare const opt: {
+    string: <R extends boolean = false>(description: string, options?: {
+        required?: R;
+        choices?: {
+            name: string;
+            value: string;
+        }[];
+        minLength?: number;
+        maxLength?: number;
+    }) => OptionDef<"string", R>;
+    integer: <R extends boolean = false>(description: string, options?: {
+        required?: R;
+        choices?: {
+            name: string;
+            value: number;
+        }[];
+        min?: number;
+        max?: number;
+    }) => OptionDef<"integer", R>;
+    number: <R extends boolean = false>(description: string, options?: {
+        required?: R;
+        choices?: {
+            name: string;
+            value: number;
+        }[];
+        min?: number;
+        max?: number;
+    }) => OptionDef<"number", R>;
+    boolean: <R extends boolean = false>(description: string, options?: {
+        required?: R;
+    }) => OptionDef<"boolean", R>;
+    user: <R extends boolean = false>(description: string, options?: {
+        required?: R;
+    }) => OptionDef<"user", R>;
+    channel: <R extends boolean = false>(description: string, options?: {
+        required?: R;
+    }) => OptionDef<"channel", R>;
+    role: <R extends boolean = false>(description: string, options?: {
+        required?: R;
+    }) => OptionDef<"role", R>;
+};
+
+type InteractionReplyOptions = string | {
+    content?: string;
+    embeds?: any[];
+    components?: any[];
+    ephemeral?: boolean;
+};
+declare class CommandContext<Options = Record<string, any>> {
+    options: Options;
+    user: User;
+    guild?: Guild | {
+        id: string;
+    } | undefined;
+    channel?: Channel | {
+        id: string;
+    } | undefined;
+    interactionId: string;
+    interactionToken: string;
+    private _client;
+    private _deferred;
+    private _replied;
+    constructor(client: Client, rawInteraction: Record<string, any>, parsedOptions: Options, user: User, guild?: Guild | {
+        id: string;
+    }, channel?: Channel | {
+        id: string;
+    });
+    get replied(): boolean;
+    get deferred(): boolean;
+    reply(payload: InteractionReplyOptions): Promise<void>;
+    defer(options?: {
+        ephemeral?: boolean;
+    }): Promise<void>;
+    followUp(payload: InteractionReplyOptions): Promise<void>;
+    showModal(modal: any): Promise<void>;
+}
+
+type ExecuteFunction<O extends Record<string, OptionDef<any, boolean>>> = (ctx: CommandContext<ResolveOptions<O>>) => void | Promise<void>;
+interface Subcommand<O extends Record<string, OptionDef<any, boolean>> = Record<string, never>> {
+    description: string;
+    options?: O;
+    execute: ExecuteFunction<O>;
+}
+declare function defineSubcommand<O extends Record<string, OptionDef<any, boolean>>>(def: Subcommand<O>): Subcommand<O>;
+type CommandDef<O extends Record<string, OptionDef<any, boolean>> = Record<string, never>, S extends Record<string, Subcommand<any>> = Record<string, never>> = {
+    name: string;
+    description: string;
+    options?: O;
+    subcommands?: S;
+    execute?: ExecuteFunction<O>;
+};
+declare function defineCommand<O extends Record<string, OptionDef<any, boolean>>, S extends Record<string, Subcommand<any>>>(def: CommandDef<O, S>): CommandDef<O, S>;
+
+declare class ComponentContext$1 {
+    customId: string;
+    user: User;
+    guild?: Guild | {
+        id: string;
+    } | undefined;
+    channel?: Channel | {
+        id: string;
+    } | undefined;
+    message?: Record<string, unknown>;
+    interactionId: string;
+    interactionToken: string;
+    private _client;
+    private _deferred;
+    private _replied;
+    constructor(client: Client, raw: Record<string, any>, user: User, guild?: Guild | {
+        id: string;
+    }, channel?: Channel | {
+        id: string;
+    });
+    get replied(): boolean;
+    get deferred(): boolean;
+    /** Values from a select menu interaction */
+    get values(): string[];
+    reply(payload: InteractionReplyOptions): Promise<void>;
+    deferUpdate(): Promise<void>;
+    update(payload: InteractionReplyOptions): Promise<void>;
+    followUp(payload: InteractionReplyOptions): Promise<void>;
+}
+declare class ModalContext {
+    customId: string;
+    user: User;
+    guild?: Guild | {
+        id: string;
+    } | undefined;
+    channel?: Channel | {
+        id: string;
+    } | undefined;
+    interactionId: string;
+    interactionToken: string;
+    private _fields;
+    private _client;
+    private _replied;
+    private _deferred;
+    constructor(client: Client, raw: Record<string, any>, user: User, guild?: Guild | {
+        id: string;
+    }, channel?: Channel | {
+        id: string;
+    });
+    get replied(): boolean;
+    get deferred(): boolean;
+    /** Get a text input value by its customId */
+    getField(customId: string): string | undefined;
+    /** Get all field values as a plain object */
+    get fields(): Record<string, string>;
+    reply(payload: InteractionReplyOptions): Promise<void>;
+    defer(options?: {
+        ephemeral?: boolean;
+    }): Promise<void>;
+    followUp(payload: InteractionReplyOptions): Promise<void>;
+}
+
+interface ComponentHandler {
+    customId: string | RegExp;
+    execute: (ctx: ComponentContext$1) => any | Promise<any>;
+}
+interface ModalHandler {
+    customId: string | RegExp;
+    execute: (ctx: ModalContext) => any | Promise<any>;
+}
+declare class CommandManager {
+    private _commands;
+    private _components;
+    private _modals;
+    private _client;
+    constructor(client: Client);
+    register(...commands: CommandDef<any, any>[]): void;
+    registerComponent(handler: ComponentHandler): void;
+    registerModal(handler: ModalHandler): void;
+    load(directory: string): Promise<void>;
+    private _deployCommands;
+    private _transformCommand;
+    handleInteraction(raw: any): Promise<void>;
+    private _handleComponentInteraction;
+    private _handleModalInteraction;
+}
+
+declare class ComponentContext<Values = any, Fields = any> {
+    user: User;
+    guild?: Guild | {
+        id: string;
+    } | undefined;
+    channel?: Channel | {
+        id: string;
+    } | undefined;
+    interactionId: string;
+    interactionToken: string;
+    customId: string;
+    values: Values;
+    fields: Fields;
+    private _client;
+    private _deferred;
+    private _replied;
+    constructor(client: Client, rawInteraction: Record<string, any>, user: User, guild?: Guild | {
+        id: string;
+    }, channel?: Channel | {
+        id: string;
+    });
+    get replied(): boolean;
+    get deferred(): boolean;
+    reply(payload: InteractionReplyOptions): Promise<void>;
+    defer(options?: {
+        ephemeral?: boolean;
+    }): Promise<void>;
+    update(payload: InteractionReplyOptions): Promise<void>;
+    deferUpdate(): Promise<void>;
+    followUp(payload: InteractionReplyOptions): Promise<void>;
+    showModal(modal: any): Promise<void>;
+}
+declare function buildModalPayload(def: any): {
+    custom_id: any;
+    title: any;
+    components: any;
+};
+
+declare enum COMPONENT_TYPES {
+    ACTION_ROW = 1,
+    BUTTON = 2,
+    STRING_SELECT = 3,
+    TEXT_INPUT = 4,
+    USER_SELECT = 5,
+    ROLE_SELECT = 6,
+    MENTIONABLE_SELECT = 7,
+    CHANNEL_SELECT = 8
+}
+declare enum TEXT_INPUT_STYLES {
+    SHORT = 1,
+    PARAGRAPH = 2
+}
+
+type ButtonStyleString = 'primary' | 'secondary' | 'success' | 'danger' | 'link' | 'premium';
+interface ButtonDef {
+    customId?: string;
+    url?: string;
+    label?: string;
+    style: ButtonStyleString | number;
+    disabled?: boolean;
+    emoji?: Partial<Emoji>;
+    skuId?: string;
+    execute?: (ctx: ComponentContext) => void | Promise<void>;
+}
+declare function resolveButtonStyle(style: string | number): number;
+declare function defineButton(def: ButtonDef): ButtonDef & {
+    type: 'button';
+};
+interface StringSelectDef {
+    customId: string;
+    options: SelectOption[];
+    placeholder?: string;
+    minValues?: number;
+    maxValues?: number;
+    disabled?: boolean;
+    execute: (ctx: ComponentContext<string[]>) => void | Promise<void>;
+}
+declare function defineStringSelect(def: StringSelectDef): StringSelectDef & {
+    type: 'string_select';
+};
+interface UserSelectDef {
+    customId: string;
+    placeholder?: string;
+    minValues?: number;
+    maxValues?: number;
+    disabled?: boolean;
+    execute: (ctx: ComponentContext<User[]>) => void | Promise<void>;
+}
+declare function defineUserSelect(def: UserSelectDef): UserSelectDef & {
+    type: 'user_select';
+};
+interface RoleSelectDef {
+    customId: string;
+    placeholder?: string;
+    minValues?: number;
+    maxValues?: number;
+    disabled?: boolean;
+    execute: (ctx: ComponentContext<Role[]>) => void | Promise<void>;
+}
+declare function defineRoleSelect(def: RoleSelectDef): RoleSelectDef & {
+    type: 'role_select';
+};
+interface ChannelSelectDef {
+    customId: string;
+    channelTypes?: number[];
+    placeholder?: string;
+    minValues?: number;
+    maxValues?: number;
+    disabled?: boolean;
+    execute: (ctx: ComponentContext<Partial<Channel>[]>) => void | Promise<void>;
+}
+declare function defineChannelSelect(def: ChannelSelectDef): ChannelSelectDef & {
+    type: 'channel_select';
+};
+interface MentionableSelectDef {
+    customId: string;
+    placeholder?: string;
+    minValues?: number;
+    maxValues?: number;
+    disabled?: boolean;
+    execute: (ctx: ComponentContext<(User | Role)[]>) => void | Promise<void>;
+}
+declare function defineMentionableSelect(def: MentionableSelectDef): MentionableSelectDef & {
+    type: 'mentionable_select';
+};
+interface ModalFieldDef<Required extends boolean = true> {
+    id: string;
+    type: TEXT_INPUT_STYLES;
+    label: string;
+    required?: Required;
+    minLength?: number;
+    maxLength?: number;
+    placeholder?: string;
+    value?: string;
+}
+declare const field: {
+    short: <ID extends string, Req extends boolean = true>(id: ID, label: string, options?: {
+        required?: Req;
+        minLength?: number;
+        maxLength?: number;
+        placeholder?: string;
+        value?: string;
+    }) => ModalFieldDef<Req> & {
+        id: ID;
+    };
+    paragraph: <ID extends string, Req extends boolean = true>(id: ID, label: string, options?: {
+        required?: Req;
+        minLength?: number;
+        maxLength?: number;
+        placeholder?: string;
+        value?: string;
+    }) => ModalFieldDef<Req> & {
+        id: ID;
+    };
+};
+type ResolveModalFields<F extends ReadonlyArray<ModalFieldDef<any>>> = {
+    [K in F[number] as K['id']]: K['required'] extends false ? string | undefined : string;
+};
+interface ModalDef<F extends ReadonlyArray<ModalFieldDef<any>>> {
+    customId: string;
+    title: string;
+    fields: F;
+    execute: (ctx: ComponentContext<never, ResolveModalFields<F>>) => void | Promise<void>;
+}
+declare function defineModal<F extends ReadonlyArray<ModalFieldDef<any>>>(def: ModalDef<F>): ModalDef<F> & {
+    type: 'modal';
+};
+
+declare const ActionRow: {
+    of: (...components: any[]) => {
+        type: COMPONENT_TYPES;
+        components: any[];
+    };
+};
+
+declare class ComponentManager {
+    private client;
+    private handlers;
+    constructor(client: Client);
+    register(...components: any[]): void;
+    handleInteraction(raw: Record<string, any>): Promise<void>;
+}
+
+declare abstract class BaseManager<T extends {
+    id: string;
+}> {
+    protected rest: ChameleonREST;
+    protected store: TongueStore;
+    constructor(rest: ChameleonREST, store: TongueStore);
+    protected abstract endpoint(id: string): string;
+    protected abstract build(raw: unknown): T;
+    protected abstract storeKey: keyof TongueStore;
+    fetch(id: string, force?: boolean): Promise<ChameleonAPIResult<T>>;
+}
+
+declare const Colors: {
+    readonly Blue: 2003199;
+    readonly Purple: 10181046;
+    readonly Orange: 16744272;
+    readonly Pink: 16739201;
+    readonly White: 16777215;
+    readonly Blurple: 5793266;
+    readonly Green: 5763719;
+    readonly Yellow: 16705372;
+    readonly Fuchsia: 15418782;
+    readonly Red: 15548997;
+    readonly Black: 2303786;
+    readonly Transparent: 3092790;
+};
+declare class EmbedBuilder {
+    private data;
+    constructor(data?: Partial<Embed> | Record<string, unknown>);
+    setTitle(title: string): this;
+    setDescription(description: string): this;
+    setColor(color: number): this;
+    setURL(url: string): this;
+    setTimestamp(ts?: Date | number): this;
+    setFooter(text: string, iconUrl?: string): this;
+    setAuthor(name: string, iconUrl?: string, url?: string): this;
+    setImage(url: string): this;
+    setThumbnail(url: string): this;
+    addField(name: string, value: string, inline?: boolean): this;
+    addFields(...fields: EmbedField[]): this;
+    build(): Embed;
+    toJSON(): Record<string, unknown>;
+}
+
+declare class ButtonBuilder {
+    private data;
+    setCustomId(id: string): this;
+    setLabel(label: string): this;
+    setStyle(style: number): this;
+    setEmoji(emoji: Partial<Emoji>): this;
+    setDisabled(disabled?: boolean): this;
+    setURL(url: string): this;
+    build(): MessageComponent;
+    toJSON(): MessageComponent;
+}
+declare class SelectMenuBuilder {
+    private data;
+    setCustomId(id: string): this;
+    setPlaceholder(placeholder: string): this;
+    setMinValues(min: number): this;
+    setMaxValues(max: number): this;
+    setDisabled(disabled?: boolean): this;
+    addOption(option: SelectOption): this;
+    addOptions(...options: SelectOption[]): this;
+    setType(type: number): this;
+    build(): MessageComponent;
+    toJSON(): MessageComponent;
+}
+declare class TextInputBuilder {
+    private data;
+    setCustomId(id: string): this;
+    setLabel(label: string): this;
+    setStyle(style: number): this;
+    setPlaceholder(placeholder: string): this;
+    private _minLength?;
+    private _maxLength?;
+    private _required?;
+    private _value?;
+    setMinLength(length: number): this;
+    setMaxLength(length: number): this;
+    setRequired(required?: boolean): this;
+    setValue(value: string): this;
+    build(): MessageComponent;
+    toJSON(): any;
+}
+declare class ActionRowBuilder {
+    private data;
+    addComponent(component: MessageComponent | {
+        build(): MessageComponent;
+    }): this;
+    addComponents(...components: (MessageComponent | {
+        build(): MessageComponent;
+    })[]): this;
+    build(): MessageComponent;
+    toJSON(): MessageComponent;
+}
+declare class ModalBuilder {
+    private _title;
+    private _customId;
+    private _components;
+    setTitle(title: string): this;
+    setCustomId(id: string): this;
+    addComponent(row: MessageComponent | {
+        build(): MessageComponent;
+    }): this;
+    addComponents(...rows: (MessageComponent | {
+        build(): MessageComponent;
+    })[]): this;
+    build(): {
+        title: string;
+        custom_id: string;
+        components: MessageComponent[];
+    };
+    toJSON(): {
+        title: string;
+        custom_id: string;
+        components: MessageComponent[];
+    };
+}
+
+declare function buildUser(raw: Record<string, unknown>): User;
+declare function buildChannel(raw: Record<string, unknown>, guildId?: string): Channel;
+declare function buildGuild(raw: Record<string, unknown>): Guild;
+declare function buildRole(raw: Record<string, unknown>): Role;
+declare function buildMember(raw: Record<string, unknown>, guildId: string, cache: TongueStore): Member;
+declare function buildMessage(raw: Record<string, unknown>, cache: TongueStore, oldMessage?: Message): Message;
+declare function resolveChannel(channelId: string, cache: TongueStore): Channel | {
+    id: string;
+};
+declare function resolveGuild(guildId: string, cache: TongueStore): Guild | {
+    id: string;
+};
+declare function resolveUser(userId: string, cache: TongueStore): User | {
+    id: string;
+};
+declare function resolveRole(roleId: string, cache: TongueStore): Role | {
+    id: string;
+};
+
+declare class UserManager extends BaseManager<User> {
+    protected storeKey: "users";
+    protected endpoint(id: string): string;
+    protected build: typeof buildUser;
+}
+
+declare class GuildManager extends BaseManager<Guild> {
+    protected storeKey: "guilds";
+    protected endpoint(id: string): string;
+    protected build: typeof buildGuild;
+    fetchChannels(guildId: string): Promise<ChameleonAPIResult<Channel[]>>;
+    ban(guildId: string, userId: string, options?: {
+        deleteMessageSeconds?: number;
+        reason?: string;
+    }): Promise<ChameleonAPIResult<void>>;
+    unban(guildId: string, userId: string, reason?: string): Promise<ChameleonAPIResult<void>>;
+    kick(guildId: string, userId: string, reason?: string): Promise<ChameleonAPIResult<void>>;
+}
+
+declare class ChannelManager extends BaseManager<Channel> {
+    protected storeKey: "channels";
+    protected endpoint(id: string): string;
+    protected build: typeof buildChannel;
+}
+
+declare class MemberManager {
+    protected rest: ChameleonREST;
+    protected store: TongueStore;
+    private guildId;
+    constructor(rest: ChameleonREST, store: TongueStore, guildId: string);
+    fetch(userId: string, force?: boolean): Promise<ChameleonAPIResult<Member>>;
+}
+
+declare class MessageManager {
+    protected rest: ChameleonREST;
+    protected store: TongueStore;
+    constructor(rest: ChameleonREST, store: TongueStore);
+    fetch(channelId: string, messageId: string, force?: boolean): Promise<ChameleonAPIResult<Message>>;
+    send(channelId: string, payload: string | Record<string, any>): Promise<ChameleonAPIResult<Message>>;
+    edit(channelId: string, messageId: string, payload: string | Record<string, any>): Promise<ChameleonAPIResult<Message>>;
+    delete(channelId: string, messageId: string): Promise<ChameleonAPIResult<void>>;
+}
+
+interface AwaitMessagesOptions {
+    filter?: (message: Message) => boolean;
+    max?: number;
+    time?: number;
+}
+interface AwaitComponentOptions {
+    filter?: (ctx: ComponentContext$1) => boolean;
+    time?: number;
+}
+declare class CollectorManager {
+    private client;
+    constructor(client: Client);
+    /**
+     * Waits for a specified number of messages in a given channel that pass the filter, if the time limit
+     * is reached, resolves with the messages collected so far
+     */
+    awaitMessages(channelId: string, options?: AwaitMessagesOptions): Promise<Message[]>;
+    /**
+     * waits for a single component interaction on a specific message,
+     * resolves with the ComponentContext if successful, or null if it timed out
+     */
+    awaitComponent(messageId: string, options?: AwaitComponentOptions): Promise<ComponentContext$1 | null>;
+}
+
+interface ClientOptions<TIntents extends readonly IntentResolvable[]> {
+    token: string;
+    intents: TIntents;
+    largeThreshold?: number;
+    sharding?: 'auto' | {
+        shards: number[];
+        total: number;
+    };
+    cluster?: boolean;
+    cache?: StoreOptions;
+    debug?: boolean;
+}
+type EventMap = {
+    [K in ChameleonEvent['type']]: Extract<ChameleonEvent, {
+        type: K;
+    }>;
+};
+type MiddlewareFn = (event: ChameleonEvent, next: () => void) => void | Promise<void>;
+declare class Client<TIntents extends readonly IntentResolvable[] = readonly IntentResolvable[]> {
+    token: string;
+    intents: number;
+    cache: TongueStore;
+    rest: ChameleonREST;
+    gateways: Map<number, ChameleonGateway>;
+    totalShards: number;
+    gateway: ChameleonGateway;
+    user: User | null;
+    private unavailableGuilds;
+    private outageGuilds;
+    private pendingChunks;
+    debug: boolean;
+    commands: CommandManager;
+    components: ComponentManager;
+    users: UserManager;
+    guilds: GuildManager;
+    channels: ChannelManager;
+    messages: MessageManager;
+    collectors: CollectorManager;
+    private listeners;
+    private middlewares;
+    constructor(options: ClientOptions<TIntents>);
+    private resolveIntents;
+    /**
+     * register an event listener with full type-safety via discriminated unions
+     */
+    on<K extends keyof EventMap>(event: K, listener: (data: EventMap[K]) => void): this;
+    /**
+     * remove an event listener
+     */
+    off<K extends keyof EventMap>(event: K, listener: (data: EventMap[K]) => void): this;
+    /**
+     * register middleware that runs between dispatch and event handlers
+     */
+    use(fn: MiddlewareFn): this;
+    getShardForGuild(guildId: string): number;
+    /**
+     * request offline/large guild members from the Gateway.
+     * This is used to lazy-load members into the cache or search for specific members
+     */
+    requestGuildMembers(options: {
+        guildId: string | string[];
+        query?: string;
+        limit: number;
+        presences?: boolean;
+        userIds?: string | string[];
+        nonce?: string;
+    }): void;
+    /**
+     * Connect to all Gateways
+     */
+    login(): Promise<void>;
+    /**
+     * Gracefully disconnect from all Gateways
+     */
+    destroy(): void;
+    /**
+     * Update presence/status across all shards
+     */
+    presence(options: {
+        status?: 'online' | 'dnd' | 'idle' | 'invisible' | 'offline';
+        activities?: Array<{
+            name: string;
+            type: number;
+            url?: string;
+            state?: string;
+        }>;
+        afk?: boolean;
+        since?: number | null;
+    }): void;
+    /**
+     * dispatch an event through the middleware pipeline, then to listeners
+     */
+    private dispatch;
+    /**
+     * emit to registered listeners
+     */
+    private emit;
+    private setupGateway;
+    private handleDispatch;
+}
+
+type PermissionFlag = typeof DISCORD_PERMISSIONS[keyof typeof DISCORD_PERMISSIONS];
+/**
+ * Check if a permission string contains a specific flag
+ */
+declare function hasPermission(permissions: string | bigint, flag: bigint): boolean;
+/**
+ * Check if a permission string contains ALL of the given flags
+ */
+declare function hasAllPermissions(permissions: string | bigint, ...flags: bigint[]): boolean;
+/**
+ * Check if a permission string contains ANY of the given flags
+ */
+declare function hasAnyPermission(permissions: string | bigint, ...flags: bigint[]): boolean;
+/**
+ * Combine multiple permission flags into one bigint
+ */
+declare function combinePermissions(...flags: bigint[]): bigint;
+/**
+ * List all permission names present in a permission string
+ */
+declare function listPermissions(permissions: string | bigint): string[];
+
+declare class Chameleon {
+    static get lifespan(): {
+        readonly ram: number;
+        readonly cpu: number | undefined;
+    };
+}
+
+export { AUDIT_LOG_EVENT_TYPES, ActionRow, ActionRowBuilder, Activity, type ActivityInstance, type ActivityLocation, ActivityLocationKind, type Application, type ApplicationCommand, type ApplicationCommandOption, type ApplicationCommandOptionChoice, ApplicationCommandOptionType, ApplicationCommandType, ApplicationEventWebhookStatus, ApplicationFlag, ApplicationIntegrationType, type ApplicationIntegrationTypeConfiguration, type ApplicationRoleConnection, type ApplicationRoleConnectionMetadata, ApplicationRoleConnectionMetadataType, type Attachment, AttachmentFlag, type AuditLog, type AuditLogChange, type AuditLogEntry, type AutoModerationAction, type AutoModerationActionMetadata, AutoModerationActionType, AutoModerationEventType, AutoModerationKeywordPresetType, type AutoModerationRule, type AutoModerationTriggerMetadata, AutoModerationTriggerType, type AvatarDecorationData, BaseManager, ButtonBuilder, type ButtonDef, ButtonStyle, type ButtonStyleString, CHAMELEON_SELF_MAP, Chameleon, type ChameleonAPIResult, type ChameleonEvent, type ChameleonEventHandler, ChameleonGateway, type ChameleonGatewayOptions, ChameleonREST, type ChameleonRESTOptions, type ChameleonSelfKey, type Channel, ChannelFlag, ChannelManager, type ChannelMention, type ChannelSelectDef, ChannelType, Client, type ClientOptions, type Collectibles, CollectorManager, Colors, CommandContext, type CommandDef, CommandManager, ComponentContext, type ComponentHandler, ComponentManager, ComponentType, type Connection, DISCORD_GATEWAY_OPCODES, DISCORD_PERMISSIONS, DefaultMessageNotificationLevel, type DefaultReaction, type Embed, type EmbedAuthor, EmbedBuilder, type EmbedField, type EmbedFooter, type EmbedImage, type EmbedProvider, EmbedType, type EmbedVideo, type Emoji, type Entitlement, EntitlementType, type ExecuteFunction, ExplicitContentFilterLevel, ForumLayoutType, type ForumTag, type GatewayPayload, type GatewayStatus, type Guild, GuildInviteFlag, GuildManager, GuildMemberFlag, GuildNSFWLevel, type GuildScheduledEvent, type GuildScheduledEventEntityMetadata, GuildScheduledEventEntityType, GuildScheduledEventPrivacyLevel, GuildScheduledEventStatus, type GuildTemplate, type HttpMethod, type IncidentsData, type InstallParams, type Integration, type IntegrationAccount, IntegrationExpireBehavior, IntentBits, type IntentResolvable, type IntentString, Intents, type InteractionReplyOptions, type Invite, type InviteMetadata, type InviteStageInstance, InviteTargetType, InviteType, type Lobby, type LobbyMember, LobbyMemberFlag, MFALevel, type Member, MemberManager, type MentionableSelectDef, type Message, type MessageActivity, MessageActivityType, type MessageCall, type MessageComponent, MessageFlag, type MessageInteractionMetadata, MessageManager, type MessageReference, MessageReferenceType, type MessageSnapshot, MessageType, type MiddlewareFn, ModalBuilder, type ModalDef, type ModalFieldDef, type ModalHandler, type Nameplate, type OptionDef, type OptionType, type OptionalAuditEntryInfo, type Overwrite, type PartialChannel, type PartialGuild, type PermissionFlag, type Poll, type PollAnswer, type PollAnswerCount, type PollCreateRequest, type PollMedia, type PollResults, PremiumTier, PremiumType, type Reaction, type ReactionCountDetails, type ResolveModalFields, type ResolveOption, type ResolveOptionType, type ResolveOptions, type Role, type RoleSelectDef, type RoleSubscriptionData, type RoleTags, SelectMenuBuilder, type SelectOption, type SharedClientTheme, type Sku, SkuFlag, SkuType, SortOrderType, type SoundboardSound, type StageInstance, StagePrivacyLevel, type Sticker, StickerFormatType, type StickerItem, type StickerPack, StickerType, type StoreOptions, type StringSelectDef, type Subcommand, type Subscription, SubscriptionStatus, SystemChannelFlag, type Team, type TeamMember, TextInputBuilder, type ThreadMember, type ThreadMetadata, Tongue, TongueStore, type User, UserFlag, UserManager, type UserPrimaryGuild, type UserSelectDef, VerificationLevel, VideoQualityMode, VisibilityType, type Voice, type Webhook, WebhookType, type WelcomeScreen, type WelcomeScreenChannel, buildChannel, buildGuild, buildMember, buildMessage, buildModalPayload, buildRole, buildUser, combinePermissions, defineButton, defineChannelSelect, defineCommand, defineMentionableSelect, defineModal, defineRoleSelect, defineStringSelect, defineSubcommand, defineUserSelect, field, hasAllPermissions, hasAnyPermission, hasPermission, listPermissions, opt, resolveButtonStyle, resolveChannel, resolveGuild, resolveRole, resolveUser };