@argentina-community/events-descriptions 1.0.0

package/dist/index.d.cts

@@ -0,0 +1,1314 @@
+import { AnyThreadChannel, ApplicationCommandPermissionsUpdateData, AuditLogEvent, AutoModerationActionType, AutoModerationRule, AutoModerationRuleEventType, AutoModerationRuleTriggerType, AutoModerationTriggerMetadata, ClientEvents, Collection, DMChannel, Entitlement, EntitlementType, Guild, GuildAuditLogsEntry, GuildEmoji, GuildMember, GuildMemberFlagsBitField, GuildScheduledEvent, GuildScheduledEventEntityType, Interaction, InviteType, Locale, Message, MessageMentions, MessageType, NonThreadGuildBasedChannel, OmitPartialGroupDMChannel, PermissionsBitField, Presence, Role, Snowflake, SoundboardSound, StageInstance, StageInstancePrivacyLevel, Sticker, StickerFormatType, Subscription, SubscriptionStatus, ThreadMember, User, VoiceChannelEffectSendAnimationType, VoiceState } from "discord.js";
+
+//#region rolldown:runtime
+
+//#endregion
+//#region ../../../../types/utils/utils.d.ts
+
+type Nullable$1<T> = T | null;
+//#endregion
+//#region src/lib/utils/record-update.d.ts
+interface ComputeUpdateOpts {
+  excludeDefaults?: boolean;
+}
+type UpdateValue<T> = T extends readonly unknown[] ? number : T extends ((...args: unknown[]) => unknown) | object | symbol ? never : T;
+type UpdateKeys<T> = { [K in keyof T]: UpdateValue<T[K]> extends never ? never : K }[keyof T];
+type MappedProps<T extends object, U extends T, M extends Record<string, keyof T & keyof U>> = { [K in keyof M]: UpdateValue<U[M[K]]> };
+type UnmappedProps<T extends object, U extends T, M extends Record<string, keyof T & keyof U>> = { [K in Exclude<UpdateKeys<U & T>, M[keyof M]>]: UpdateValue<(U & T)[K]> };
+type ComputeUpdatesReturn<T extends object, U extends T, M extends Record<string, keyof T & keyof U>, O extends ComputeUpdateOpts> = O extends {
+  excludeDefaults: true;
+} ? Partial<MappedProps<T, U, M>> : Partial<MappedProps<T, U, M> & UnmappedProps<T, U, M>>;
+type ComputedUpdate<T extends object, U extends T = T, M extends Record<string, keyof T & keyof U> = {}, O extends ComputeUpdateOpts = {}> = ReturnType<typeof computeUpdates<T, U, M, O>>;
+declare function computeUpdates<T extends object, U extends T, M extends Record<string, keyof T & keyof U> = {}, O extends ComputeUpdateOpts = {}>(previous: Nullable$1<T>, current: U, mappings?: M, options?: ComputeUpdateOpts): ComputeUpdatesReturn<T, U, M, O>;
+//#endregion
+//#region src/lib/description/interface/event-body.interface.d.ts
+type EventBodyMapper<T extends keyof ClientEvents & keyof EventBodyMap> = (...payload: ClientEvents[T]) => EventBodyMap[T];
+declare namespace client_application_scope_bodies_d_exports {
+  export { cacheSweep$2 as cacheSweep, guildAvailable$2 as guildAvailable, guildMemberAvailable$2 as guildMemberAvailable, guildMembersChunk$2 as guildMembersChunk, guildUnavailable$2 as guildUnavailable, invalidated$2 as invalidated, soundboardSounds$2 as soundboardSounds, threadListSync$2 as threadListSync, threadMemberUpdate$2 as threadMemberUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    guildAvailable: {
+      name: string;
+      vanity: Nullable<string>;
+      ownerId: Snowflake;
+      locale: Locale;
+      large: boolean;
+      verified: boolean;
+      partnered: boolean;
+      createdAt: number;
+      shard: number;
+    };
+    guildUnavailable: {
+      name: string;
+      vanity: Nullable<string>;
+      ownerId: Snowflake;
+      locale: Locale;
+      large: boolean;
+      verified: boolean;
+      partnered: boolean;
+      createdAt: number;
+      shard: number;
+    };
+    guildMemberAvailable: {
+      name: string;
+      userId: Snowflake;
+      joinedAt: Nullable<number>;
+      permissions: bigint;
+      premium: boolean;
+    };
+    guildMembersChunk: {
+      size: number;
+      shard: number;
+    };
+    threadMemberUpdate: ComputedUpdate<ThreadMember>;
+    threadListSync: {
+      size: number;
+      shard: number;
+    };
+    soundboardSounds: {
+      size: number;
+      shard: number;
+    };
+    cacheSweep: {
+      message: string;
+    };
+    invalidated: object;
+  }
+}
+declare const guildAvailable$2: EventBodyMapper<'guildAvailable'>;
+declare const guildUnavailable$2: EventBodyMapper<'guildUnavailable'>;
+declare const guildMemberAvailable$2: EventBodyMapper<'guildMemberAvailable'>;
+declare const guildMembersChunk$2: EventBodyMapper<'guildMembersChunk'>;
+declare const threadMemberUpdate$2: EventBodyMapper<'threadMemberUpdate'>;
+declare const threadListSync$2: EventBodyMapper<'threadListSync'>;
+declare const soundboardSounds$2: EventBodyMapper<'soundboardSounds'>;
+declare const cacheSweep$2: EventBodyMapper<'cacheSweep'>;
+declare const invalidated$2: EventBodyMapper<'invalidated'>;
+declare namespace gateway_application_scope_bodies_d_exports {
+  export { debug$2 as debug, error$2 as error, interactionCreate$2 as interactionCreate, presenceUpdate$2 as presenceUpdate, ready$2 as ready, shardDisconnect$2 as shardDisconnect, shardError$2 as shardError, shardReady$2 as shardReady, shardReconnecting$2 as shardReconnecting, shardResume$2 as shardResume, userUpdate$2 as userUpdate, warn$2 as warn };
+}
+declare global {
+  interface EventBodyMap {
+    ready: {
+      guilds: Nullable<number>;
+      users: Nullable<number>;
+      readyAt: number;
+    };
+    error: {
+      error: string;
+      message: string;
+    };
+    warn: {
+      message: string;
+    };
+    debug: {
+      message: string;
+    };
+    shardReady: {
+      shard: number;
+    };
+    shardError: {
+      error: string;
+      message: string;
+      shard: number;
+    };
+    shardResume: {
+      shard: number;
+      replayed: number;
+    };
+    shardDisconnect: {
+      shard: number;
+      code: number;
+    };
+    shardReconnecting: {
+      shard: number;
+    };
+    userUpdate: ComputedUpdate<User>;
+    interactionCreate: {
+      type: Interaction['type'];
+      context: Interaction['context'];
+      locale: Interaction['locale'];
+      id: Interaction['id'];
+      customId: Nullable<string>;
+    };
+    presenceUpdate: {
+      status: Presence['status'];
+      activities: Presence['activities'];
+    } | object;
+  }
+}
+declare const ready$2: EventBodyMapper<'ready'>;
+declare const error$2: EventBodyMapper<'error'>;
+declare const warn$2: EventBodyMapper<'warn'>;
+declare const debug$2: EventBodyMapper<'debug'>;
+declare const shardReady$2: EventBodyMapper<'shardReady'>;
+declare const shardError$2: EventBodyMapper<'shardError'>;
+declare const shardResume$2: EventBodyMapper<'shardResume'>;
+declare const shardDisconnect$2: EventBodyMapper<'shardDisconnect'>;
+declare const shardReconnecting$2: EventBodyMapper<'shardReconnecting'>;
+declare const userUpdate$2: EventBodyMapper<'userUpdate'>;
+declare const interactionCreate$2: EventBodyMapper<'interactionCreate'>;
+declare const presenceUpdate$2: EventBodyMapper<'presenceUpdate'>;
+declare namespace installations_application_scope_bodies_d_exports {
+  export { entitlementCreate$2 as entitlementCreate, entitlementDelete$2 as entitlementDelete, entitlementUpdate$2 as entitlementUpdate, guildCreate$2 as guildCreate, guildDelete$2 as guildDelete, subscriptionCreate$2 as subscriptionCreate, subscriptionDelete$2 as subscriptionDelete, subscriptionUpdate$2 as subscriptionUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    guildCreate: {
+      name: string;
+      vanity: Nullable<string>;
+      ownerId: Snowflake;
+      locale: Locale;
+      large: boolean;
+      verified: boolean;
+      partnered: boolean;
+      createdAt: number;
+      shard: number;
+    };
+    guildDelete: {
+      name: string;
+      vanity: Nullable<string>;
+      ownerId: Snowflake;
+      locale: Locale;
+      large: boolean;
+      verified: boolean;
+      partnered: boolean;
+      createdAt: number;
+      shard: number;
+    };
+    entitlementCreate: {
+      type: EntitlementType;
+      guildId: Nullable<Snowflake>;
+      startsAt: Nullable<number>;
+      endsAt: Nullable<number>;
+    };
+    entitlementUpdate: ComputedUpdate<Entitlement>;
+    entitlementDelete: {
+      type: EntitlementType;
+      guildId: Nullable<Snowflake>;
+      startsAt: Nullable<number>;
+      endsAt: Nullable<number>;
+    };
+    subscriptionCreate: {
+      status: SubscriptionStatus;
+      country: Nullable<string>;
+      period: [startsAt: number, endsAt: number];
+    };
+    subscriptionUpdate: ComputedUpdate<Subscription>;
+    subscriptionDelete: {
+      status: SubscriptionStatus;
+      country: Nullable<string>;
+      period: [startsAt: number, endsAt: number];
+    };
+  }
+}
+declare const guildCreate$2: EventBodyMapper<'guildCreate'>;
+declare const guildDelete$2: EventBodyMapper<'guildDelete'>;
+declare const entitlementCreate$2: EventBodyMapper<'entitlementCreate'>;
+declare const entitlementUpdate$2: EventBodyMapper<'entitlementUpdate'>;
+declare const entitlementDelete$2: EventBodyMapper<'entitlementDelete'>;
+declare const subscriptionCreate$2: EventBodyMapper<'subscriptionCreate'>;
+declare const subscriptionUpdate$2: EventBodyMapper<'subscriptionUpdate'>;
+declare const subscriptionDelete$2: EventBodyMapper<'subscriptionDelete'>;
+declare namespace actions_channel_scope_bodies_d_exports {
+  export { channelPinsUpdate$2 as channelPinsUpdate, messageDeleteBulk$2 as messageDeleteBulk, typingStart$2 as typingStart };
+}
+declare global {
+  interface EventBodyMap {
+    typingStart: {
+      startedAt: number;
+    };
+    messageDeleteBulk: {
+      size: number;
+    };
+    channelPinsUpdate: object;
+  }
+}
+declare const typingStart$2: EventBodyMapper<'typingStart'>;
+declare const messageDeleteBulk$2: EventBodyMapper<'messageDeleteBulk'>;
+declare const channelPinsUpdate$2: EventBodyMapper<'channelPinsUpdate'>;
+declare namespace lifecycle_channel_scope_bodies_d_exports {
+  export { channelCreate$2 as channelCreate, channelDelete$2 as channelDelete, channelUpdate$2 as channelUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    channelCreate: {
+      name: string;
+      type: NonThreadGuildBasedChannel['type'];
+    };
+    channelUpdate: ComputedUpdate<DMChannel | NonThreadGuildBasedChannel>;
+    channelDelete: {
+      name: string;
+      type: NonThreadGuildBasedChannel['type'];
+    } | {
+      type: DMChannel['type'];
+    };
+  }
+}
+declare const channelCreate$2: EventBodyMapper<'channelCreate'>;
+declare const channelUpdate$2: EventBodyMapper<'channelUpdate'>;
+declare const channelDelete$2: EventBodyMapper<'channelDelete'>;
+declare namespace stage_channel_scope_bodies_d_exports {
+  export { stageInstanceCreate$2 as stageInstanceCreate, stageInstanceDelete$2 as stageInstanceDelete, stageInstanceUpdate$2 as stageInstanceUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    stageInstanceCreate: {
+      topic: string;
+      privacy: StageInstancePrivacyLevel;
+    };
+    stageInstanceUpdate: ComputedUpdate<StageInstance>;
+    stageInstanceDelete: {
+      topic: string;
+      privacy: StageInstancePrivacyLevel;
+    };
+  }
+}
+declare const stageInstanceCreate$2: EventBodyMapper<'stageInstanceCreate'>;
+declare const stageInstanceUpdate$2: EventBodyMapper<'stageInstanceUpdate'>;
+declare const stageInstanceDelete$2: EventBodyMapper<'stageInstanceDelete'>;
+declare namespace voice_channel_scope_bodies_d_exports {
+  export { voiceChannelEffectSend$2 as voiceChannelEffectSend, voiceStateUpdate$2 as voiceStateUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    voiceStateUpdate: ComputedUpdate<VoiceState>;
+    voiceChannelEffectSend: {
+      type: Nullable<VoiceChannelEffectSendAnimationType>;
+      soundId: Nullable<Snowflake>;
+    };
+  }
+}
+declare const voiceStateUpdate$2: EventBodyMapper<'voiceStateUpdate'>;
+declare const voiceChannelEffectSend$2: EventBodyMapper<'voiceChannelEffectSend'>;
+declare namespace webhook_channel_scope_bodies_d_exports {
+  export { webhookUpdate$2 as webhookUpdate, webhooksUpdate$2 as webhooksUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    webhookUpdate: object;
+    webhooksUpdate: object;
+  }
+}
+declare const webhookUpdate$2: EventBodyMapper<'webhookUpdate'>;
+declare const webhooksUpdate$2: EventBodyMapper<'webhooksUpdate'>;
+declare namespace configuration_guild_scope_bodies_d_exports {
+  export { applicationCommandPermissionsUpdate$2 as applicationCommandPermissionsUpdate, autoModerationActionExecution$2 as autoModerationActionExecution, autoModerationRuleCreate$2 as autoModerationRuleCreate, autoModerationRuleDelete$2 as autoModerationRuleDelete, autoModerationRuleUpdate$2 as autoModerationRuleUpdate, guildIntegrationsUpdate$2 as guildIntegrationsUpdate, guildUpdate$2 as guildUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    guildIntegrationsUpdate: object;
+    applicationCommandPermissionsUpdate: {
+      permissions: ApplicationCommandPermissionsUpdateData['permissions'];
+    };
+    guildUpdate: ComputedUpdate<Guild, Guild>;
+    autoModerationRuleCreate: {
+      name: string;
+      event: AutoModerationRuleEventType;
+      trigger: AutoModerationRuleTriggerType;
+    };
+    autoModerationRuleUpdate: ComputedUpdate<AutoModerationRule> & ComputedUpdate<AutoModerationTriggerMetadata> & ComputedUpdate<{
+      exemptChannels: number;
+      exemptRoles: number;
+    }>;
+    autoModerationRuleDelete: {
+      name: string;
+      event: AutoModerationRuleEventType;
+      trigger: AutoModerationRuleTriggerType;
+    };
+    autoModerationActionExecution: {
+      match: string;
+      action: AutoModerationActionType;
+      trigger: AutoModerationRuleTriggerType;
+      userId: Snowflake;
+    };
+  }
+}
+declare const guildIntegrationsUpdate$2: EventBodyMapper<'guildIntegrationsUpdate'>;
+declare const applicationCommandPermissionsUpdate$2: EventBodyMapper<'applicationCommandPermissionsUpdate'>;
+declare const guildUpdate$2: EventBodyMapper<'guildUpdate'>;
+declare const autoModerationRuleCreate$2: EventBodyMapper<'autoModerationRuleCreate'>;
+declare const autoModerationRuleUpdate$2: EventBodyMapper<'autoModerationRuleUpdate'>;
+declare const autoModerationRuleDelete$2: EventBodyMapper<'autoModerationRuleDelete'>;
+declare const autoModerationActionExecution$2: EventBodyMapper<'autoModerationActionExecution'>;
+declare namespace members_guild_scope_bodies_d_exports {
+  export { guildBanAdd$2 as guildBanAdd, guildBanRemove$2 as guildBanRemove, guildMemberAdd$2 as guildMemberAdd, guildMemberRemove$2 as guildMemberRemove, guildMemberUpdate$2 as guildMemberUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    guildMemberAdd: {
+      userId: Snowflake;
+      joinedAt: Nullable<number>;
+    };
+    guildMemberUpdate: ComputedUpdate<GuildMember, GuildMember> & ComputedUpdate<Readonly<PermissionsBitField>, Readonly<PermissionsBitField>, {
+      permissions: 'bitfield';
+    }, {
+      excludeDefaults: true;
+    }> & ComputedUpdate<Readonly<GuildMemberFlagsBitField>, Readonly<GuildMemberFlagsBitField>, {
+      flags: 'bitfield';
+    }, {
+      excludeDefaults: true;
+    }> & ComputedUpdate<Collection<string, Role>, Collection<string, Role>, {
+      roles: 'size';
+    }, {
+      excludeDefaults: true;
+    }>;
+    guildMemberRemove: {
+      userId: Snowflake;
+      joinedAt: Nullable<number>;
+    };
+    guildBanAdd: {
+      reason: Nullable<string>;
+    };
+    guildBanRemove: {
+      reason: Nullable<string>;
+    };
+  }
+}
+declare const guildMemberAdd$2: EventBodyMapper<'guildMemberAdd'>;
+declare const guildMemberUpdate$2: EventBodyMapper<'guildMemberUpdate'>;
+declare const guildMemberRemove$2: EventBodyMapper<'guildMemberRemove'>;
+declare const guildBanAdd$2: EventBodyMapper<'guildBanAdd'>;
+declare const guildBanRemove$2: EventBodyMapper<'guildBanRemove'>;
+declare namespace events_guild_scope_bodies_d_exports {
+  export { guildScheduledEventCreate$2 as guildScheduledEventCreate, guildScheduledEventDelete$2 as guildScheduledEventDelete, guildScheduledEventUpdate$2 as guildScheduledEventUpdate, guildScheduledEventUserAdd$2 as guildScheduledEventUserAdd, guildScheduledEventUserRemove$2 as guildScheduledEventUserRemove };
+}
+declare global {
+  interface EventBodyMap {
+    guildScheduledEventCreate: {
+      type: Nullable<GuildScheduledEventEntityType>;
+      name: Nullable<string>;
+      createdAt: number;
+    };
+    guildScheduledEventUpdate: ComputedUpdate<GuildScheduledEvent, GuildScheduledEvent>;
+    guildScheduledEventDelete: {
+      type: Nullable<GuildScheduledEventEntityType>;
+      name: Nullable<string>;
+      createdAt: number;
+    };
+    guildScheduledEventUserAdd: {
+      event: Nullable<string>;
+      createdAt: number;
+    };
+    guildScheduledEventUserRemove: {
+      event: Nullable<string>;
+      createdAt: number;
+    };
+  }
+}
+declare const guildScheduledEventCreate$2: EventBodyMapper<'guildScheduledEventCreate'>;
+declare const guildScheduledEventUpdate$2: EventBodyMapper<'guildScheduledEventUpdate'>;
+declare const guildScheduledEventDelete$2: EventBodyMapper<'guildScheduledEventDelete'>;
+declare const guildScheduledEventUserAdd$2: EventBodyMapper<'guildScheduledEventUserAdd'>;
+declare const guildScheduledEventUserRemove$2: EventBodyMapper<'guildScheduledEventUserRemove'>;
+declare namespace expressions_guild_scope_bodies_d_exports {
+  export { emojiCreate$2 as emojiCreate, emojiDelete$2 as emojiDelete, emojiUpdate$2 as emojiUpdate, guildSoundboardSoundCreate$2 as guildSoundboardSoundCreate, guildSoundboardSoundDelete$2 as guildSoundboardSoundDelete, guildSoundboardSoundUpdate$2 as guildSoundboardSoundUpdate, stickerCreate$2 as stickerCreate, stickerDelete$2 as stickerDelete, stickerUpdate$2 as stickerUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    guildSoundboardSoundCreate: {
+      name: string;
+      createdAt: number;
+    };
+    guildSoundboardSoundUpdate: ComputedUpdate<SoundboardSound, SoundboardSound>;
+    guildSoundboardSoundDelete: {
+      name: Nullable<string>;
+      createdAt: number;
+    };
+    emojiCreate: {
+      name: Nullable<string>;
+      emoji: string;
+      createdAt: number;
+    };
+    emojiUpdate: ComputedUpdate<GuildEmoji, GuildEmoji>;
+    emojiDelete: {
+      name: Nullable<string>;
+      emoji: string;
+      createdAt: number;
+    };
+    stickerCreate: {
+      name: string;
+      format: StickerFormatType;
+      createdAt: number;
+    };
+    stickerUpdate: ComputedUpdate<Sticker, Sticker>;
+    stickerDelete: {
+      name: string;
+      format: StickerFormatType;
+      createdAt: number;
+    };
+  }
+}
+declare const guildSoundboardSoundCreate$2: EventBodyMapper<'guildSoundboardSoundCreate'>;
+declare const guildSoundboardSoundUpdate$2: EventBodyMapper<'guildSoundboardSoundUpdate'>;
+declare const guildSoundboardSoundDelete$2: EventBodyMapper<'guildSoundboardSoundDelete'>;
+declare const emojiCreate$2: EventBodyMapper<'emojiCreate'>;
+declare const emojiUpdate$2: EventBodyMapper<'emojiUpdate'>;
+declare const emojiDelete$2: EventBodyMapper<'emojiDelete'>;
+declare const stickerCreate$2: EventBodyMapper<'stickerCreate'>;
+declare const stickerUpdate$2: EventBodyMapper<'stickerUpdate'>;
+declare const stickerDelete$2: EventBodyMapper<'stickerDelete'>;
+declare namespace invites_guild_scope_bodies_d_exports {
+  export { inviteCreate$2 as inviteCreate, inviteDelete$2 as inviteDelete };
+}
+declare global {
+  interface EventBodyMap {
+    inviteCreate: {
+      type: InviteType;
+      createdAt: Nullable<number>;
+      expiresAt: Nullable<number>;
+    };
+    inviteDelete: {
+      type: InviteType;
+      createdAt: Nullable<number>;
+      expiresAt: Nullable<number>;
+    };
+  }
+}
+declare const inviteCreate$2: EventBodyMapper<'inviteCreate'>;
+declare const inviteDelete$2: EventBodyMapper<'inviteDelete'>;
+declare namespace logs_guild_scope_bodies_d_exports {
+  export { guildAuditLogEntryCreate$2 as guildAuditLogEntryCreate };
+}
+declare global {
+  interface EventBodyMap {
+    guildAuditLogEntryCreate: {
+      event: AuditLogEvent;
+      action: GuildAuditLogsEntry['actionType'];
+      createdAt: number;
+    };
+  }
+}
+declare const guildAuditLogEntryCreate$2: EventBodyMapper<'guildAuditLogEntryCreate'>;
+declare namespace roles_guild_scope_bodies_d_exports {
+  export { roleCreate$2 as roleCreate, roleDelete$2 as roleDelete, roleUpdate$2 as roleUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    roleCreate: {
+      name: string;
+      createdAt: number;
+    };
+    roleUpdate: ComputedUpdate<Role, Role> & ComputedUpdate<Readonly<PermissionsBitField>, Readonly<PermissionsBitField>, {
+      permissions: 'bitfield';
+    }, {
+      excludeDefaults: true;
+    }>;
+    roleDelete: {
+      name: string;
+      createdAt: number;
+    };
+  }
+}
+declare const roleCreate$2: EventBodyMapper<'roleCreate'>;
+declare const roleUpdate$2: EventBodyMapper<'roleUpdate'>;
+declare const roleDelete$2: EventBodyMapper<'roleDelete'>;
+declare namespace lifecycle_message_scope_bodies_d_exports {
+  export { messageCreate$2 as messageCreate, messageDelete$2 as messageDelete, messageUpdate$2 as messageUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    messageCreate: {
+      content: string;
+      type: Nullable<MessageType>;
+      nonce: Nullable<string | number>;
+      userId: Snowflake;
+    };
+    messageUpdate: ComputedUpdate<OmitPartialGroupDMChannel<Message<boolean>>> & ComputedUpdate<MessageMentions> & ComputedUpdate<{
+      reactions: number;
+      attachments: number;
+    }>;
+    messageDelete: {
+      content: Nullable<string>;
+      type: Nullable<MessageType>;
+      nonce: Nullable<string | number>;
+      userId: Nullable<Snowflake>;
+    };
+  }
+}
+declare const messageCreate$2: EventBodyMapper<'messageCreate'>;
+declare const messageUpdate$2: EventBodyMapper<'messageUpdate'>;
+declare const messageDelete$2: EventBodyMapper<'messageDelete'>;
+declare namespace polls_message_scope_bodies_d_exports {
+  export { messagePollVoteAdd$2 as messagePollVoteAdd, messagePollVoteRemove$2 as messagePollVoteRemove };
+}
+declare global {
+  interface EventBodyMap {
+    messagePollVoteAdd: {
+      text: Nullable<string>;
+      multichoice: boolean;
+    };
+    messagePollVoteRemove: {
+      text: Nullable<string>;
+      multichoice: boolean;
+    };
+  }
+}
+declare const messagePollVoteAdd$2: EventBodyMapper<'messagePollVoteAdd'>;
+declare const messagePollVoteRemove$2: EventBodyMapper<'messagePollVoteRemove'>;
+declare namespace reactions_message_scope_bodies_d_exports {
+  export { messageReactionAdd$2 as messageReactionAdd, messageReactionRemove$2 as messageReactionRemove, messageReactionRemoveAll$2 as messageReactionRemoveAll, messageReactionRemoveEmoji$2 as messageReactionRemoveEmoji };
+}
+declare global {
+  interface EventBodyMap {
+    messageReactionAdd: {
+      reactions: Nullable<number>;
+      animated: Nullable<boolean>;
+    };
+    messageReactionRemove: {
+      reactions: Nullable<number>;
+      animated: Nullable<boolean>;
+    };
+    messageReactionRemoveAll: {
+      size: number;
+    };
+    messageReactionRemoveEmoji: {
+      reactions: Nullable<number>;
+      animated: Nullable<boolean>;
+    };
+  }
+}
+declare const messageReactionAdd$2: EventBodyMapper<'messageReactionAdd'>;
+declare const messageReactionRemove$2: EventBodyMapper<'messageReactionRemove'>;
+declare const messageReactionRemoveAll$2: EventBodyMapper<'messageReactionRemoveAll'>;
+declare const messageReactionRemoveEmoji$2: EventBodyMapper<'messageReactionRemoveEmoji'>;
+declare namespace lifecycle_thread_scope_bodies_d_exports {
+  export { threadCreate$2 as threadCreate, threadDelete$2 as threadDelete, threadUpdate$2 as threadUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    threadCreate: {
+      name: string;
+      type: AnyThreadChannel['type'];
+      ownerId: Snowflake;
+    };
+    threadUpdate: ComputedUpdate<AnyThreadChannel>;
+    threadDelete: {
+      name: string;
+      type: AnyThreadChannel['type'];
+      ownerId: Snowflake;
+    };
+  }
+}
+declare const threadCreate$2: EventBodyMapper<'threadCreate'>;
+declare const threadUpdate$2: EventBodyMapper<'threadUpdate'>;
+declare const threadDelete$2: EventBodyMapper<'threadDelete'>;
+declare namespace members_thread_scope_bodies_d_exports {
+  export { threadMembersUpdate$2 as threadMembersUpdate };
+}
+declare global {
+  interface EventBodyMap {
+    threadMembersUpdate: {
+      added: number;
+      removed: number;
+      members: number;
+    };
+  }
+}
+declare const threadMembersUpdate$2: EventBodyMapper<'threadMembersUpdate'>;
+//#endregion
+//#region src/lib/description/event-body.d.ts
+declare const BodyMap: { [Event in keyof EventBodyMap]: (...args: ClientEvents[Event]) => EventBodyMap[Event] };
+//#endregion
+//#region src/lib/description/utils/components.d.ts
+type UserId = Snowflake & {};
+type RecipientId = Snowflake & {};
+type MemberId = Snowflake & {};
+type GuildId = Snowflake & {};
+type RoleId = Snowflake & {};
+type ChannelId = Snowflake & {};
+type MessageId = Snowflake & {};
+type ThreadId = Snowflake & {};
+type EmojiId = Snowflake & {};
+type ApplicationId = Snowflake & {};
+type CommandId = Snowflake & {};
+type RuleId = Snowflake & {};
+type EventId = Snowflake & {};
+type AnswerId = number & {};
+type InviteCode = string & {};
+type ShardId = number & {};
+type StickerId = Snowflake & {};
+type SubscriptionId = Snowflake & {};
+type EntitlementId = Snowflake & {};
+type SoundId = Snowflake & {};
+declare const UNKNOWN: "?";
+type Unknown = typeof UNKNOWN;
+type MaybeUnknown<T extends string | number> = T | Unknown;
+declare enum ProducerKind {
+  Gateway = "gateway",
+  Client = "client",
+  Actor = "actor",
+}
+declare enum OriginNamespace {
+  System = "system",
+  Guild = "guild",
+  User = "user",
+  Member = "member",
+  Direct = "direct",
+  Group = "group",
+}
+//#endregion
+//#region src/lib/description/interface/event-callpoint.interface.d.ts
+type EventCallpointMapper<T extends keyof ClientEvents & keyof EventCallpointMap> = (...payload: ClientEvents[T]) => EventCallpointMap[T];
+interface CallpointObject<Shard extends number | Unknown, Location extends string> {
+  shard: Shard;
+  location: Location;
+}
+declare namespace client_application_scope_callpoints_d_exports {
+  export { cacheSweep$1 as cacheSweep, guildAvailable$1 as guildAvailable, guildMemberAvailable$1 as guildMemberAvailable, guildMembersChunk$1 as guildMembersChunk, guildUnavailable$1 as guildUnavailable, invalidated$1 as invalidated, soundboardSounds$1 as soundboardSounds, threadListSync$1 as threadListSync, threadMemberUpdate$1 as threadMemberUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    guildAvailable: CallpointObject<ShardId, `/guilds/${GuildId}`>;
+    guildUnavailable: CallpointObject<ShardId, `/guilds/${GuildId}`>;
+    guildMemberAvailable: CallpointObject<ShardId, `/guilds/${GuildId}/members/${MemberId}`>;
+    guildMembersChunk: CallpointObject<ShardId, `/guilds/${GuildId}/members`>;
+    threadMemberUpdate: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ThreadId}/thread-members/${UserId}`>;
+    threadListSync: CallpointObject<ShardId, `/guilds/${GuildId}/threads`>;
+    soundboardSounds: CallpointObject<ShardId, `/guilds/${GuildId}/soundboard-sounds`>;
+    cacheSweep: CallpointObject<Unknown, `/client/cache`>;
+    invalidated: CallpointObject<Unknown, `/client/state`>;
+  }
+}
+declare const guildAvailable$1: EventCallpointMapper<'guildAvailable'>;
+declare const guildUnavailable$1: EventCallpointMapper<'guildUnavailable'>;
+declare const guildMemberAvailable$1: EventCallpointMapper<'guildMemberAvailable'>;
+declare const guildMembersChunk$1: EventCallpointMapper<'guildMembersChunk'>;
+declare const threadMemberUpdate$1: EventCallpointMapper<'threadMemberUpdate'>;
+declare const threadListSync$1: EventCallpointMapper<'threadListSync'>;
+declare const soundboardSounds$1: EventCallpointMapper<'soundboardSounds'>;
+declare const cacheSweep$1: EventCallpointMapper<'cacheSweep'>;
+declare const invalidated$1: EventCallpointMapper<'invalidated'>;
+declare namespace gateway_application_scope_callpoints_d_exports {
+  export { debug$1 as debug, error$1 as error, interactionCreate$1 as interactionCreate, presenceUpdate$1 as presenceUpdate, ready$1 as ready, shardDisconnect$1 as shardDisconnect, shardError$1 as shardError, shardReady$1 as shardReady, shardReconnecting$1 as shardReconnecting, shardResume$1 as shardResume, userUpdate$1 as userUpdate, warn$1 as warn };
+}
+declare global {
+  interface EventCallpointMap {
+    ready: CallpointObject<Unknown, `/client`>;
+    error: CallpointObject<Unknown, `/client`>;
+    warn: CallpointObject<Unknown, `/client`>;
+    debug: CallpointObject<Unknown, `/client`>;
+    shardReady: CallpointObject<ShardId, `/client/shards`>;
+    shardError: CallpointObject<ShardId, `/client/shards`>;
+    shardResume: CallpointObject<ShardId, `/client/shards`>;
+    shardDisconnect: CallpointObject<ShardId, `/client/shards`>;
+    shardReconnecting: CallpointObject<ShardId, `/client/shards`>;
+    userUpdate: CallpointObject<Unknown, `/users/${UserId}`>;
+    interactionCreate: CallpointObject<MaybeUnknown<ShardId>, `/interactions`>;
+    presenceUpdate: CallpointObject<MaybeUnknown<ShardId>, `/presences`>;
+  }
+}
+declare const ready$1: EventCallpointMapper<'ready'>;
+declare const error$1: EventCallpointMapper<'error'>;
+declare const warn$1: EventCallpointMapper<'warn'>;
+declare const debug$1: EventCallpointMapper<'debug'>;
+declare const shardReady$1: EventCallpointMapper<'shardReady'>;
+declare const shardError$1: EventCallpointMapper<'shardError'>;
+declare const shardResume$1: EventCallpointMapper<'shardResume'>;
+declare const shardDisconnect$1: EventCallpointMapper<'shardDisconnect'>;
+declare const shardReconnecting$1: EventCallpointMapper<'shardReconnecting'>;
+declare const userUpdate$1: EventCallpointMapper<'userUpdate'>;
+declare const interactionCreate$1: EventCallpointMapper<'interactionCreate'>;
+declare const presenceUpdate$1: EventCallpointMapper<'presenceUpdate'>;
+declare namespace installations_application_scope_callpoints_d_exports {
+  export { entitlementCreate$1 as entitlementCreate, entitlementDelete$1 as entitlementDelete, entitlementUpdate$1 as entitlementUpdate, guildCreate$1 as guildCreate, guildDelete$1 as guildDelete, subscriptionCreate$1 as subscriptionCreate, subscriptionDelete$1 as subscriptionDelete, subscriptionUpdate$1 as subscriptionUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    guildCreate: CallpointObject<ShardId, `/guilds`>;
+    guildDelete: CallpointObject<ShardId, `/guilds`>;
+    entitlementCreate: CallpointObject<MaybeUnknown<ShardId>, `/applications/${ApplicationId}/entitlements`>;
+    entitlementUpdate: CallpointObject<MaybeUnknown<ShardId>, `/applications/${ApplicationId}/entitlements/${EntitlementId}`>;
+    entitlementDelete: CallpointObject<MaybeUnknown<ShardId>, `/applications/${ApplicationId}/entitlements/${EntitlementId}`>;
+    subscriptionCreate: CallpointObject<Unknown, `/applications/${ApplicationId}/subscriptions`>;
+    subscriptionUpdate: CallpointObject<Unknown, `/applications/${ApplicationId}/subscriptions/${SubscriptionId}`>;
+    subscriptionDelete: CallpointObject<Unknown, `/applications/${ApplicationId}/subscriptions/${SubscriptionId}`>;
+  }
+}
+declare const guildCreate$1: EventCallpointMapper<'guildCreate'>;
+declare const guildDelete$1: EventCallpointMapper<'guildDelete'>;
+declare const entitlementCreate$1: EventCallpointMapper<'entitlementCreate'>;
+declare const entitlementUpdate$1: EventCallpointMapper<'entitlementUpdate'>;
+declare const entitlementDelete$1: EventCallpointMapper<'entitlementDelete'>;
+declare const subscriptionCreate$1: EventCallpointMapper<'subscriptionCreate'>;
+declare const subscriptionUpdate$1: EventCallpointMapper<'subscriptionUpdate'>;
+declare const subscriptionDelete$1: EventCallpointMapper<'subscriptionDelete'>;
+declare namespace actions_channel_scope_callpoints_d_exports {
+  export { channelPinsUpdate$1 as channelPinsUpdate, messageDeleteBulk$1 as messageDeleteBulk, typingStart$1 as typingStart };
+}
+declare global {
+  interface EventCallpointMap {
+    typingStart: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}/typing`>;
+    messageDeleteBulk: CallpointObject<ShardId, `/channels/${ChannelId}/messages/bulk-delete`>;
+    channelPinsUpdate: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}/messages/pins`>;
+  }
+}
+declare const typingStart$1: EventCallpointMapper<'typingStart'>;
+declare const messageDeleteBulk$1: EventCallpointMapper<'messageDeleteBulk'>;
+declare const channelPinsUpdate$1: EventCallpointMapper<'channelPinsUpdate'>;
+declare namespace lifecycle_channel_scope_callpoints_d_exports {
+  export { channelCreate$1 as channelCreate, channelDelete$1 as channelDelete, channelUpdate$1 as channelUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    channelCreate: CallpointObject<ShardId, `/channels`>;
+    channelUpdate: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}`>;
+    channelDelete: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}`>;
+  }
+}
+declare const channelCreate$1: EventCallpointMapper<'channelCreate'>;
+declare const channelUpdate$1: EventCallpointMapper<'channelUpdate'>;
+declare const channelDelete$1: EventCallpointMapper<'channelDelete'>;
+declare namespace stage_channel_scope_callpoints_d_exports {
+  export { stageInstanceCreate$1 as stageInstanceCreate, stageInstanceDelete$1 as stageInstanceDelete, stageInstanceUpdate$1 as stageInstanceUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    stageInstanceCreate: CallpointObject<MaybeUnknown<ShardId>, `/stage-instances`>;
+    stageInstanceUpdate: CallpointObject<MaybeUnknown<ShardId>, `/stage-instances/${ChannelId}`>;
+    stageInstanceDelete: CallpointObject<MaybeUnknown<ShardId>, `/stage-instances/${ChannelId}`>;
+  }
+}
+declare const stageInstanceCreate$1: EventCallpointMapper<'stageInstanceCreate'>;
+declare const stageInstanceUpdate$1: EventCallpointMapper<'stageInstanceUpdate'>;
+declare const stageInstanceDelete$1: EventCallpointMapper<'stageInstanceDelete'>;
+declare namespace voice_channel_scope_callpoints_d_exports {
+  export { voiceChannelEffectSend$1 as voiceChannelEffectSend, voiceStateUpdate$1 as voiceStateUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    voiceStateUpdate: CallpointObject<ShardId, `/guilds/${GuildId}/voice-states/${MaybeUnknown<MemberId>}`>;
+    voiceChannelEffectSend: CallpointObject<ShardId, `/guilds/${GuildId}/voice-effects/${MaybeUnknown<UserId>}`>;
+  }
+}
+declare const voiceStateUpdate$1: EventCallpointMapper<'voiceStateUpdate'>;
+declare const voiceChannelEffectSend$1: EventCallpointMapper<'voiceChannelEffectSend'>;
+declare namespace webhook_channel_scope_callpoints_d_exports {
+  export { webhookUpdate$1 as webhookUpdate, webhooksUpdate$1 as webhooksUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    webhookUpdate: CallpointObject<ShardId, `/channels/${ChannelId}/webhooks`>;
+    webhooksUpdate: CallpointObject<ShardId, `/channels/${ChannelId}/webhooks`>;
+  }
+}
+declare const webhookUpdate$1: EventCallpointMapper<'webhookUpdate'>;
+declare const webhooksUpdate$1: EventCallpointMapper<'webhooksUpdate'>;
+declare namespace configuration_guild_scope_callpoints_d_exports {
+  export { applicationCommandPermissionsUpdate$1 as applicationCommandPermissionsUpdate, autoModerationActionExecution$1 as autoModerationActionExecution, autoModerationRuleCreate$1 as autoModerationRuleCreate, autoModerationRuleDelete$1 as autoModerationRuleDelete, autoModerationRuleUpdate$1 as autoModerationRuleUpdate, guildIntegrationsUpdate$1 as guildIntegrationsUpdate, guildUpdate$1 as guildUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    guildIntegrationsUpdate: CallpointObject<ShardId, `/guilds/${GuildId}/integrations/${Unknown}`>;
+    applicationCommandPermissionsUpdate: CallpointObject<Unknown, `/guilds/${GuildId}/applications/${ApplicationId}/commands/${CommandId}/permissions`>;
+    guildUpdate: CallpointObject<ShardId, `/guilds/${GuildId}`>;
+    autoModerationRuleCreate: CallpointObject<ShardId, `/guilds/${GuildId}/auto-moderation/rules`>;
+    autoModerationRuleUpdate: CallpointObject<ShardId, `/guilds/${GuildId}/auto-moderation/rules/${RuleId}`>;
+    autoModerationRuleDelete: CallpointObject<ShardId, `/guilds/${GuildId}/auto-moderation/rules/${RuleId}`>;
+    autoModerationActionExecution: CallpointObject<ShardId, `/guilds/${GuildId}/auto-moderation/rules/${RuleId}`>;
+  }
+}
+declare const guildIntegrationsUpdate$1: EventCallpointMapper<'guildIntegrationsUpdate'>;
+declare const applicationCommandPermissionsUpdate$1: EventCallpointMapper<'applicationCommandPermissionsUpdate'>;
+declare const guildUpdate$1: EventCallpointMapper<'guildUpdate'>;
+declare const autoModerationRuleCreate$1: EventCallpointMapper<'autoModerationRuleCreate'>;
+declare const autoModerationRuleUpdate$1: EventCallpointMapper<'autoModerationRuleUpdate'>;
+declare const autoModerationRuleDelete$1: EventCallpointMapper<'autoModerationRuleDelete'>;
+declare const autoModerationActionExecution$1: EventCallpointMapper<'autoModerationActionExecution'>;
+declare namespace members_guild_scope_callpoints_d_exports {
+  export { guildBanAdd$1 as guildBanAdd, guildBanRemove$1 as guildBanRemove, guildMemberAdd$1 as guildMemberAdd, guildMemberRemove$1 as guildMemberRemove, guildMemberUpdate$1 as guildMemberUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    guildMemberAdd: CallpointObject<ShardId, `/guilds/${GuildId}/members/${UserId}`>;
+    guildMemberUpdate: CallpointObject<ShardId, `/guilds/${GuildId}/members/${UserId}`>;
+    guildMemberRemove: CallpointObject<ShardId, `/guilds/${GuildId}/members/${UserId}`>;
+    guildBanAdd: CallpointObject<ShardId, `/guilds/${GuildId}/bans/${UserId}`>;
+    guildBanRemove: CallpointObject<ShardId, `/guilds/${GuildId}/bans/${UserId}`>;
+  }
+}
+declare const guildMemberAdd$1: EventCallpointMapper<'guildMemberAdd'>;
+declare const guildMemberUpdate$1: EventCallpointMapper<'guildMemberUpdate'>;
+declare const guildMemberRemove$1: EventCallpointMapper<'guildMemberRemove'>;
+declare const guildBanAdd$1: EventCallpointMapper<'guildBanAdd'>;
+declare const guildBanRemove$1: EventCallpointMapper<'guildBanRemove'>;
+declare namespace events_guild_scope_callpoints_d_exports {
+  export { guildScheduledEventCreate$1 as guildScheduledEventCreate, guildScheduledEventDelete$1 as guildScheduledEventDelete, guildScheduledEventUpdate$1 as guildScheduledEventUpdate, guildScheduledEventUserAdd$1 as guildScheduledEventUserAdd, guildScheduledEventUserRemove$1 as guildScheduledEventUserRemove };
+}
+declare global {
+  interface EventCallpointMap {
+    guildScheduledEventCreate: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${GuildId}/scheduled-events`>;
+    guildScheduledEventUpdate: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${GuildId}/scheduled-events/${EventId}`>;
+    guildScheduledEventDelete: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${GuildId}/scheduled-events/${EventId}`>;
+    guildScheduledEventUserAdd: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${GuildId}/scheduled-events/${EventId}/users`>;
+    guildScheduledEventUserRemove: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${GuildId}/scheduled-events/${EventId}/users`>;
+  }
+}
+declare const guildScheduledEventCreate$1: EventCallpointMapper<'guildScheduledEventCreate'>;
+declare const guildScheduledEventUpdate$1: EventCallpointMapper<'guildScheduledEventUpdate'>;
+declare const guildScheduledEventDelete$1: EventCallpointMapper<'guildScheduledEventDelete'>;
+declare const guildScheduledEventUserAdd$1: EventCallpointMapper<'guildScheduledEventUserAdd'>;
+declare const guildScheduledEventUserRemove$1: EventCallpointMapper<'guildScheduledEventUserRemove'>;
+declare namespace expressions_guild_scope_callpoints_d_exports {
+  export { emojiCreate$1 as emojiCreate, emojiDelete$1 as emojiDelete, emojiUpdate$1 as emojiUpdate, guildSoundboardSoundCreate$1 as guildSoundboardSoundCreate, guildSoundboardSoundDelete$1 as guildSoundboardSoundDelete, guildSoundboardSoundUpdate$1 as guildSoundboardSoundUpdate, stickerCreate$1 as stickerCreate, stickerDelete$1 as stickerDelete, stickerUpdate$1 as stickerUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    guildSoundboardSoundCreate: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${GuildId}/soundboard-sounds`>;
+    guildSoundboardSoundUpdate: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${MaybeUnknown<GuildId>}/soundboard-sounds/${SoundId}`>;
+    guildSoundboardSoundDelete: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${MaybeUnknown<GuildId>}/soundboard-sounds/${SoundId}`>;
+    emojiCreate: CallpointObject<ShardId, `/guilds/${GuildId}/emojis`>;
+    emojiUpdate: CallpointObject<ShardId, `/guilds/${GuildId}/emojis/${EmojiId}`>;
+    emojiDelete: CallpointObject<ShardId, `/guilds/${GuildId}/emojis/${EmojiId}`>;
+    stickerCreate: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${MaybeUnknown<GuildId>}/stickers`>;
+    stickerUpdate: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${MaybeUnknown<GuildId>}/stickers/${StickerId}`>;
+    stickerDelete: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${MaybeUnknown<GuildId>}/stickers/${StickerId}`>;
+  }
+}
+declare const guildSoundboardSoundCreate$1: EventCallpointMapper<'guildSoundboardSoundCreate'>;
+declare const guildSoundboardSoundUpdate$1: EventCallpointMapper<'guildSoundboardSoundUpdate'>;
+declare const guildSoundboardSoundDelete$1: EventCallpointMapper<'guildSoundboardSoundDelete'>;
+declare const emojiCreate$1: EventCallpointMapper<'emojiCreate'>;
+declare const emojiUpdate$1: EventCallpointMapper<'emojiUpdate'>;
+declare const emojiDelete$1: EventCallpointMapper<'emojiDelete'>;
+declare const stickerCreate$1: EventCallpointMapper<'stickerCreate'>;
+declare const stickerUpdate$1: EventCallpointMapper<'stickerUpdate'>;
+declare const stickerDelete$1: EventCallpointMapper<'stickerDelete'>;
+declare namespace invites_guild_scope_callpoints_d_exports {
+  export { inviteCreate$1 as inviteCreate, inviteDelete$1 as inviteDelete };
+}
+declare global {
+  interface EventCallpointMap {
+    inviteCreate: CallpointObject<MaybeUnknown<ShardId>, `/guilds/${GuildId}/invites`> | CallpointObject<Unknown, `/groups/${MaybeUnknown<ChannelId>}/invites`>;
+    inviteDelete: CallpointObject<MaybeUnknown<ShardId>, `/invites/${InviteCode}`> | CallpointObject<Unknown, `/invites/${InviteCode}`>;
+  }
+}
+declare const inviteCreate$1: EventCallpointMapper<'inviteCreate'>;
+declare const inviteDelete$1: EventCallpointMapper<'inviteDelete'>;
+declare namespace logs_guild_scope_callpoints_d_exports {
+  export { guildAuditLogEntryCreate$1 as guildAuditLogEntryCreate };
+}
+declare global {
+  interface EventCallpointMap {
+    guildAuditLogEntryCreate: CallpointObject<ShardId, `/guilds/${GuildId}/audit-logs`>;
+  }
+}
+declare const guildAuditLogEntryCreate$1: EventCallpointMapper<'guildAuditLogEntryCreate'>;
+declare namespace roles_guild_scope_callpoints_d_exports {
+  export { roleCreate$1 as roleCreate, roleDelete$1 as roleDelete, roleUpdate$1 as roleUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    roleCreate: CallpointObject<ShardId, `/guilds/${GuildId}/roles`>;
+    roleUpdate: CallpointObject<ShardId, `/guilds/${GuildId}/roles/${RoleId}`>;
+    roleDelete: CallpointObject<ShardId, `/guilds/${GuildId}/roles/${RoleId}`>;
+  }
+}
+declare const roleCreate$1: EventCallpointMapper<'roleCreate'>;
+declare const roleUpdate$1: EventCallpointMapper<'roleUpdate'>;
+declare const roleDelete$1: EventCallpointMapper<'roleDelete'>;
+declare namespace lifecycle_message_scope_callpoints_d_exports {
+  export { messageCreate$1 as messageCreate, messageDelete$1 as messageDelete, messageUpdate$1 as messageUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    messageCreate: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}/messages`>;
+    messageUpdate: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}/messages/${MessageId}`>;
+    messageDelete: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}/messages/${MessageId}`>;
+  }
+}
+declare const messageCreate$1: EventCallpointMapper<'messageCreate'>;
+declare const messageUpdate$1: EventCallpointMapper<'messageUpdate'>;
+declare const messageDelete$1: EventCallpointMapper<'messageDelete'>;
+declare namespace polls_message_scope_callpoints_d_exports {
+  export { messagePollVoteAdd$1 as messagePollVoteAdd, messagePollVoteRemove$1 as messagePollVoteRemove };
+}
+declare global {
+  interface EventCallpointMap {
+    messagePollVoteAdd: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}/polls/${MessageId}/answers/${AnswerId}`>;
+    messagePollVoteRemove: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}/polls/${MessageId}/answers/${AnswerId}`>;
+  }
+}
+declare const messagePollVoteAdd$1: EventCallpointMapper<'messagePollVoteAdd'>;
+declare const messagePollVoteRemove$1: EventCallpointMapper<'messagePollVoteRemove'>;
+declare namespace reactions_message_scope_callpoints_d_exports {
+  export { messageReactionAdd$1 as messageReactionAdd, messageReactionRemove$1 as messageReactionRemove, messageReactionRemoveAll$1 as messageReactionRemoveAll, messageReactionRemoveEmoji$1 as messageReactionRemoveEmoji };
+}
+declare global {
+  interface EventCallpointMap {
+    messageReactionAdd: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}/messages/${MessageId}/reactions/${MaybeUnknown<EmojiId>}`>;
+    messageReactionRemove: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}/messages/${MessageId}/reactions/${MaybeUnknown<EmojiId>}/${UserId}`>;
+    messageReactionRemoveAll: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}/messages/${MessageId}/reactions`>;
+    messageReactionRemoveEmoji: CallpointObject<MaybeUnknown<ShardId>, `/channels/${ChannelId}/messages/${MessageId}/reactions/${EmojiId}`>;
+  }
+}
+declare const messageReactionAdd$1: EventCallpointMapper<'messageReactionAdd'>;
+declare const messageReactionRemove$1: EventCallpointMapper<'messageReactionRemove'>;
+declare const messageReactionRemoveAll$1: EventCallpointMapper<'messageReactionRemoveAll'>;
+declare const messageReactionRemoveEmoji$1: EventCallpointMapper<'messageReactionRemoveEmoji'>;
+declare namespace lifecycle_thread_scope_callpoints_d_exports {
+  export { threadCreate$1 as threadCreate, threadDelete$1 as threadDelete, threadUpdate$1 as threadUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    threadCreate: CallpointObject<ShardId, `/channels/${MaybeUnknown<ChannelId>}/messages/${MessageId}/threads` | `/channels/${MaybeUnknown<ChannelId>}/threads`>;
+    threadUpdate: CallpointObject<ShardId, `/channels/${ThreadId}`>;
+    threadDelete: CallpointObject<ShardId, `/channels/${ThreadId}`>;
+  }
+}
+declare const threadCreate$1: EventCallpointMapper<'threadCreate'>;
+declare const threadUpdate$1: EventCallpointMapper<'threadUpdate'>;
+declare const threadDelete$1: EventCallpointMapper<'threadDelete'>;
+declare namespace members_thread_scope_callpoints_d_exports {
+  export { threadMembersUpdate$1 as threadMembersUpdate };
+}
+declare global {
+  interface EventCallpointMap {
+    threadMembersUpdate: CallpointObject<ShardId, `/channels/${ChannelId}/thread-members`>;
+  }
+}
+declare const threadMembersUpdate$1: EventCallpointMapper<'threadMembersUpdate'>;
+//#endregion
+//#region src/lib/description/event-callpoint.d.ts
+declare const CallpointMap: { [Event in keyof EventCallpointMap]: (...args: ClientEvents[Event]) => EventCallpointMap[Event] };
+//#endregion
+//#region src/lib/description/interface/event-origin.interface.d.ts
+type EventOriginMapper<T extends keyof ClientEvents & keyof EventOriginMap> = (...payload: ClientEvents[T]) => EventOriginMap[T];
+interface OriginObject<Kind extends ProducerKind, Namespace extends OriginNamespace, T> {
+  kind: Kind;
+  namespace: Namespace;
+  value: T;
+}
+declare namespace client_application_scope_origins_d_exports {
+  export { cacheSweep, guildAvailable, guildMemberAvailable, guildMembersChunk, guildUnavailable, invalidated, soundboardSounds, threadListSync, threadMemberUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    guildAvailable: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    guildUnavailable: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    guildMemberAvailable: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${MemberId}`>;
+    guildMembersChunk: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    threadMemberUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${MaybeUnknown<GuildId>}:${MemberId}`>;
+    threadListSync: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    soundboardSounds: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    cacheSweep: OriginObject<ProducerKind.Gateway, OriginNamespace.System, 'cache'>;
+    invalidated: OriginObject<ProducerKind.Gateway, OriginNamespace.System, 'cache'>;
+  }
+}
+declare const guildAvailable: EventOriginMapper<'guildAvailable'>;
+declare const guildUnavailable: EventOriginMapper<'guildUnavailable'>;
+declare const guildMemberAvailable: EventOriginMapper<'guildMemberAvailable'>;
+declare const guildMembersChunk: EventOriginMapper<'guildMembersChunk'>;
+declare const threadMemberUpdate: EventOriginMapper<'threadMemberUpdate'>;
+declare const threadListSync: EventOriginMapper<'threadListSync'>;
+declare const soundboardSounds: EventOriginMapper<'soundboardSounds'>;
+declare const cacheSweep: EventOriginMapper<'cacheSweep'>;
+declare const invalidated: EventOriginMapper<'invalidated'>;
+declare namespace gateway_application_scope_origins_d_exports {
+  export { debug, error, interactionCreate, presenceUpdate, ready, shardDisconnect, shardError, shardReady, shardReconnecting, shardResume, userUpdate, warn };
+}
+declare global {
+  interface EventOriginMap {
+    ready: OriginObject<ProducerKind.Gateway, OriginNamespace.System, 'client'>;
+    error: OriginObject<ProducerKind.Gateway, OriginNamespace.System, 'client'>;
+    warn: OriginObject<ProducerKind.Gateway, OriginNamespace.System, 'client'>;
+    debug: OriginObject<ProducerKind.Gateway, OriginNamespace.System, 'client'>;
+    shardReady: OriginObject<ProducerKind.Gateway, OriginNamespace.System, 'shard'>;
+    shardError: OriginObject<ProducerKind.Gateway, OriginNamespace.System, 'shard'>;
+    shardResume: OriginObject<ProducerKind.Gateway, OriginNamespace.System, 'shard'>;
+    shardDisconnect: OriginObject<ProducerKind.Gateway, OriginNamespace.System, 'shard'>;
+    shardReconnecting: OriginObject<ProducerKind.Gateway, OriginNamespace.System, 'shard'>;
+    userUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.User, UserId>;
+    interactionCreate: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId> | OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    presenceUpdate: Nullable<OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId> | OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>>;
+  }
+}
+declare const ready: EventOriginMapper<'ready'>;
+declare const error: EventOriginMapper<'error'>;
+declare const warn: EventOriginMapper<'warn'>;
+declare const debug: EventOriginMapper<'debug'>;
+declare const shardReady: EventOriginMapper<'shardReady'>;
+declare const shardError: EventOriginMapper<'shardError'>;
+declare const shardResume: EventOriginMapper<'shardResume'>;
+declare const shardDisconnect: EventOriginMapper<'shardDisconnect'>;
+declare const shardReconnecting: EventOriginMapper<'shardReconnecting'>;
+declare const userUpdate: EventOriginMapper<'userUpdate'>;
+declare const interactionCreate: EventOriginMapper<'interactionCreate'>;
+declare const presenceUpdate: EventOriginMapper<'presenceUpdate'>;
+declare namespace installations_application_scope_origins_d_exports {
+  export { entitlementCreate, entitlementDelete, entitlementUpdate, guildCreate, guildDelete, subscriptionCreate, subscriptionDelete, subscriptionUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    guildCreate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    guildDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    entitlementCreate: OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    entitlementUpdate: OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    entitlementDelete: OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    subscriptionCreate: OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    subscriptionUpdate: OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    subscriptionDelete: OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+  }
+}
+declare const guildCreate: EventOriginMapper<'guildCreate'>;
+declare const guildDelete: EventOriginMapper<'guildDelete'>;
+declare const entitlementCreate: EventOriginMapper<'entitlementCreate'>;
+declare const entitlementUpdate: EventOriginMapper<'entitlementUpdate'>;
+declare const entitlementDelete: EventOriginMapper<'entitlementDelete'>;
+declare const subscriptionCreate: EventOriginMapper<'subscriptionCreate'>;
+declare const subscriptionUpdate: EventOriginMapper<'subscriptionUpdate'>;
+declare const subscriptionDelete: EventOriginMapper<'subscriptionDelete'>;
+declare namespace actions_channel_scope_origins_d_exports {
+  export { channelPinsUpdate, messageDeleteBulk, typingStart };
+}
+declare global {
+  interface EventOriginMap {
+    typingStart: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId> | OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    messageDeleteBulk: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`>;
+    channelPinsUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`> | OriginObject<ProducerKind.Gateway, OriginNamespace.Direct, `${RecipientId}:${ChannelId}`> | OriginObject<ProducerKind.Gateway, OriginNamespace.Group, ChannelId>;
+  }
+}
+declare const typingStart: EventOriginMapper<'typingStart'>;
+declare const messageDeleteBulk: EventOriginMapper<'messageDeleteBulk'>;
+declare const channelPinsUpdate: EventOriginMapper<'channelPinsUpdate'>;
+declare namespace lifecycle_channel_scope_origins_d_exports {
+  export { channelCreate, channelDelete, channelUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    channelCreate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`>;
+    channelUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`> | OriginObject<ProducerKind.Gateway, OriginNamespace.Direct, `${RecipientId}:${ChannelId}`>;
+    channelDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`> | OriginObject<ProducerKind.Gateway, OriginNamespace.Direct, `${RecipientId}:${ChannelId}`>;
+  }
+}
+declare const channelCreate: EventOriginMapper<'channelCreate'>;
+declare const channelUpdate: EventOriginMapper<'channelUpdate'>;
+declare const channelDelete: EventOriginMapper<'channelDelete'>;
+declare namespace stage_channel_scope_origins_d_exports {
+  export { stageInstanceCreate, stageInstanceDelete, stageInstanceUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    stageInstanceCreate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`>;
+    stageInstanceUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`>;
+    stageInstanceDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`>;
+  }
+}
+declare const stageInstanceCreate: EventOriginMapper<'stageInstanceCreate'>;
+declare const stageInstanceUpdate: EventOriginMapper<'stageInstanceUpdate'>;
+declare const stageInstanceDelete: EventOriginMapper<'stageInstanceDelete'>;
+declare namespace voice_channel_scope_origins_d_exports {
+  export { voiceChannelEffectSend, voiceStateUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    voiceStateUpdate: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MaybeUnknown<MemberId>>;
+    voiceChannelEffectSend: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId>;
+  }
+}
+declare const voiceStateUpdate: EventOriginMapper<'voiceStateUpdate'>;
+declare const voiceChannelEffectSend: EventOriginMapper<'voiceChannelEffectSend'>;
+declare namespace webhook_channel_scope_origins_d_exports {
+  export { webhookUpdate, webhooksUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    webhookUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`>;
+    webhooksUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`>;
+  }
+}
+declare const webhookUpdate: EventOriginMapper<'webhookUpdate'>;
+declare const webhooksUpdate: EventOriginMapper<'webhooksUpdate'>;
+declare namespace configuration_guild_scope_origins_d_exports {
+  export { applicationCommandPermissionsUpdate, autoModerationActionExecution, autoModerationRuleCreate, autoModerationRuleDelete, autoModerationRuleUpdate, guildIntegrationsUpdate, guildUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    guildIntegrationsUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    applicationCommandPermissionsUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    guildUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    autoModerationRuleCreate: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId>;
+    autoModerationRuleUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    autoModerationRuleDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    autoModerationActionExecution: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId>;
+  }
+}
+declare const guildIntegrationsUpdate: EventOriginMapper<'guildIntegrationsUpdate'>;
+declare const applicationCommandPermissionsUpdate: EventOriginMapper<'applicationCommandPermissionsUpdate'>;
+declare const guildUpdate: EventOriginMapper<'guildUpdate'>;
+declare const autoModerationRuleCreate: EventOriginMapper<'autoModerationRuleCreate'>;
+declare const autoModerationRuleUpdate: EventOriginMapper<'autoModerationRuleUpdate'>;
+declare const autoModerationRuleDelete: EventOriginMapper<'autoModerationRuleDelete'>;
+declare const autoModerationActionExecution: EventOriginMapper<'autoModerationActionExecution'>;
+declare namespace members_guild_scope_origins_d_exports {
+  export { guildBanAdd, guildBanRemove, guildMemberAdd, guildMemberRemove, guildMemberUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    guildMemberAdd: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId>;
+    guildMemberUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    guildMemberRemove: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    guildBanAdd: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+    guildBanRemove: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+  }
+}
+declare const guildMemberAdd: EventOriginMapper<'guildMemberAdd'>;
+declare const guildMemberUpdate: EventOriginMapper<'guildMemberUpdate'>;
+declare const guildMemberRemove: EventOriginMapper<'guildMemberRemove'>;
+declare const guildBanAdd: EventOriginMapper<'guildBanAdd'>;
+declare const guildBanRemove: EventOriginMapper<'guildBanRemove'>;
+declare namespace events_guild_scope_origins_d_exports {
+  export { guildScheduledEventCreate, guildScheduledEventDelete, guildScheduledEventUpdate, guildScheduledEventUserAdd, guildScheduledEventUserRemove };
+}
+declare global {
+  interface EventOriginMap {
+    guildScheduledEventCreate: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MaybeUnknown<MemberId>>;
+    guildScheduledEventUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`>;
+    guildScheduledEventDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`>;
+    guildScheduledEventUserAdd: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId>;
+    guildScheduledEventUserRemove: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId>;
+  }
+}
+declare const guildScheduledEventCreate: EventOriginMapper<'guildScheduledEventCreate'>;
+declare const guildScheduledEventUpdate: EventOriginMapper<'guildScheduledEventUpdate'>;
+declare const guildScheduledEventDelete: EventOriginMapper<'guildScheduledEventDelete'>;
+declare const guildScheduledEventUserAdd: EventOriginMapper<'guildScheduledEventUserAdd'>;
+declare const guildScheduledEventUserRemove: EventOriginMapper<'guildScheduledEventUserRemove'>;
+declare namespace expressions_guild_scope_origins_d_exports {
+  export { emojiCreate, emojiDelete, emojiUpdate, guildSoundboardSoundCreate, guildSoundboardSoundDelete, guildSoundboardSoundUpdate, stickerCreate, stickerDelete, stickerUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    guildSoundboardSoundCreate: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MaybeUnknown<MemberId>>;
+    guildSoundboardSoundUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, MaybeUnknown<GuildId>>;
+    guildSoundboardSoundDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, MaybeUnknown<GuildId>>;
+    emojiCreate: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MaybeUnknown<MemberId>>;
+    emojiUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, MaybeUnknown<GuildId>>;
+    emojiDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, MaybeUnknown<GuildId>>;
+    stickerCreate: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MaybeUnknown<MemberId>>;
+    stickerUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, MaybeUnknown<GuildId>>;
+    stickerDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, MaybeUnknown<GuildId>>;
+  }
+}
+declare const guildSoundboardSoundCreate: EventOriginMapper<'guildSoundboardSoundCreate'>;
+declare const guildSoundboardSoundUpdate: EventOriginMapper<'guildSoundboardSoundUpdate'>;
+declare const guildSoundboardSoundDelete: EventOriginMapper<'guildSoundboardSoundDelete'>;
+declare const emojiCreate: EventOriginMapper<'emojiCreate'>;
+declare const emojiUpdate: EventOriginMapper<'emojiUpdate'>;
+declare const emojiDelete: EventOriginMapper<'emojiDelete'>;
+declare const stickerCreate: EventOriginMapper<'stickerCreate'>;
+declare const stickerUpdate: EventOriginMapper<'stickerUpdate'>;
+declare const stickerDelete: EventOriginMapper<'stickerDelete'>;
+declare namespace invites_guild_scope_origins_d_exports {
+  export { inviteCreate, inviteDelete };
+}
+declare global {
+  interface EventOriginMap {
+    inviteCreate: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MaybeUnknown<MemberId>> | OriginObject<ProducerKind.Actor, OriginNamespace.User, MaybeUnknown<UserId>>;
+    inviteDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${MaybeUnknown<GuildId>}:${MaybeUnknown<ChannelId>}`> | OriginObject<ProducerKind.Gateway, OriginNamespace.Group, MaybeUnknown<ChannelId>> | OriginObject<ProducerKind.Gateway, OriginNamespace.Direct, MaybeUnknown<ChannelId>>;
+  }
+}
+declare const inviteCreate: EventOriginMapper<'inviteCreate'>;
+declare const inviteDelete: EventOriginMapper<'inviteDelete'>;
+declare namespace logs_guild_scope_origins_d_exports {
+  export { guildAuditLogEntryCreate };
+}
+declare global {
+  interface EventOriginMap {
+    guildAuditLogEntryCreate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, GuildId>;
+  }
+}
+declare const guildAuditLogEntryCreate: EventOriginMapper<'guildAuditLogEntryCreate'>;
+declare namespace roles_guild_scope_origins_d_exports {
+  export { roleCreate, roleDelete, roleUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    roleCreate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${RoleId}`>;
+    roleUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${RoleId}`>;
+    roleDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${RoleId}`>;
+  }
+}
+declare const roleCreate: EventOriginMapper<'roleCreate'>;
+declare const roleUpdate: EventOriginMapper<'roleUpdate'>;
+declare const roleDelete: EventOriginMapper<'roleDelete'>;
+declare namespace lifecycle_message_scope_origins_d_exports {
+  export { messageCreate, messageDelete, messageUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    messageCreate: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId> | OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    messageUpdate: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId> | OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    messageDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`> | OriginObject<ProducerKind.Gateway, OriginNamespace.Direct, `${MaybeUnknown<RecipientId>}:${ChannelId}`>;
+  }
+}
+declare const messageCreate: EventOriginMapper<'messageCreate'>;
+declare const messageUpdate: EventOriginMapper<'messageUpdate'>;
+declare const messageDelete: EventOriginMapper<'messageDelete'>;
+declare namespace polls_message_scope_origins_d_exports {
+  export { messagePollVoteAdd, messagePollVoteRemove };
+}
+declare global {
+  interface EventOriginMap {
+    messagePollVoteAdd: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId> | OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    messagePollVoteRemove: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId> | OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+  }
+}
+declare const messagePollVoteAdd: EventOriginMapper<'messagePollVoteAdd'>;
+declare const messagePollVoteRemove: EventOriginMapper<'messagePollVoteRemove'>;
+declare namespace reactions_message_scope_origins_d_exports {
+  export { messageReactionAdd, messageReactionRemove, messageReactionRemoveAll, messageReactionRemoveEmoji };
+}
+declare global {
+  interface EventOriginMap {
+    messageReactionAdd: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId> | OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    messageReactionRemove: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId> | OriginObject<ProducerKind.Actor, OriginNamespace.User, UserId>;
+    messageReactionRemoveAll: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`> | OriginObject<ProducerKind.Gateway, OriginNamespace.Group, ChannelId> | OriginObject<ProducerKind.Gateway, OriginNamespace.Direct, `${RecipientId}:${UserId}`>;
+    messageReactionRemoveEmoji: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ChannelId}`> | OriginObject<ProducerKind.Gateway, OriginNamespace.Group, ChannelId> | OriginObject<ProducerKind.Gateway, OriginNamespace.Direct, `${RecipientId}:${UserId}`>;
+  }
+}
+declare const messageReactionAdd: EventOriginMapper<'messageReactionAdd'>;
+declare const messageReactionRemove: EventOriginMapper<'messageReactionRemove'>;
+declare const messageReactionRemoveAll: EventOriginMapper<'messageReactionRemoveAll'>;
+declare const messageReactionRemoveEmoji: EventOriginMapper<'messageReactionRemoveEmoji'>;
+declare namespace lifecycle_thread_scope_origins_d_exports {
+  export { threadCreate, threadDelete, threadUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    threadCreate: OriginObject<ProducerKind.Actor, OriginNamespace.Member, MemberId>;
+    threadUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ThreadId}`>;
+    threadDelete: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ThreadId}`>;
+  }
+}
+declare const threadCreate: EventOriginMapper<'threadCreate'>;
+declare const threadUpdate: EventOriginMapper<'threadUpdate'>;
+declare const threadDelete: EventOriginMapper<'threadDelete'>;
+declare namespace members_thread_scope_origins_d_exports {
+  export { threadMembersUpdate };
+}
+declare global {
+  interface EventOriginMap {
+    threadMembersUpdate: OriginObject<ProducerKind.Gateway, OriginNamespace.Guild, `${GuildId}:${ThreadId}`>;
+  }
+}
+declare const threadMembersUpdate: EventOriginMapper<'threadMembersUpdate'>;
+//#endregion
+//#region src/lib/description/event-origin.d.ts
+declare const OriginMap: { [Event in keyof EventOriginMap]: (...args: ClientEvents[Event]) => EventOriginMap[Event] };
+//#endregion
+//#region src/lib/description/interface/event-description.interface.d.ts
+type DescriptableEvent = keyof ClientEvents & (keyof EventCallpointMap & keyof EventBodyMap & keyof EventOriginMap);
+interface EventDescription<Event extends DescriptableEvent> {
+  event: Event;
+  body: EventBodyMap[Event];
+  callpoint: EventCallpointMap[Event];
+  origin: EventOriginMap[Event];
+}
+//#endregion
+//#region src/lib/description/event-description-parser.d.ts
+declare function parse<T extends DescriptableEvent>(event: T, ...payload: ClientEvents[T]): EventDescription<T>;
+//#endregion
+export { type client_application_scope_bodies_d_exports as BodiesApplicationClientScope, type gateway_application_scope_bodies_d_exports as BodiesApplicationGatewayScope, type installations_application_scope_bodies_d_exports as BodiesApplicationInstallationsScope, type actions_channel_scope_bodies_d_exports as BodiesChannelActionsScope, type lifecycle_channel_scope_bodies_d_exports as BodiesChannelLifecycleScope, type stage_channel_scope_bodies_d_exports as BodiesChannelStageScope, type voice_channel_scope_bodies_d_exports as BodiesChannelVoiceScope, type webhook_channel_scope_bodies_d_exports as BodiesChannelWebhookScope, type configuration_guild_scope_bodies_d_exports as BodiesGuildConfigurationScope, type events_guild_scope_bodies_d_exports as BodiesGuildEventsScope, type expressions_guild_scope_bodies_d_exports as BodiesGuildExpressionsScope, type invites_guild_scope_bodies_d_exports as BodiesGuildInvitesScope, type logs_guild_scope_bodies_d_exports as BodiesGuildLogsScope, type members_guild_scope_bodies_d_exports as BodiesGuildMembersScope, type roles_guild_scope_bodies_d_exports as BodiesGuildRolesScope, type lifecycle_message_scope_bodies_d_exports as BodiesMessageLifecycleScope, type polls_message_scope_bodies_d_exports as BodiesMessagePollsScope, type reactions_message_scope_bodies_d_exports as BodiesMessageReactionsScope, type lifecycle_thread_scope_bodies_d_exports as BodiesThreadLifecycleScope, type members_thread_scope_bodies_d_exports as BodiesThreadMembersScope, BodyMap, CallpointMap, type CallpointObject, type client_application_scope_callpoints_d_exports as CallpointsApplicationClientScope, type gateway_application_scope_callpoints_d_exports as CallpointsApplicationGatewayScope, type installations_application_scope_callpoints_d_exports as CallpointsApplicationInstallationsScope, type actions_channel_scope_callpoints_d_exports as CallpointsChannelActionsScope, type lifecycle_channel_scope_callpoints_d_exports as CallpointsChannelLifecycleScope, type stage_channel_scope_callpoints_d_exports as CallpointsChannelStageScope, type voice_channel_scope_callpoints_d_exports as CallpointsChannelVoiceScope, type webhook_channel_scope_callpoints_d_exports as CallpointsChannelWebhookScope, type configuration_guild_scope_callpoints_d_exports as CallpointsGuildConfigurationScope, type events_guild_scope_callpoints_d_exports as CallpointsGuildEventsScope, type expressions_guild_scope_callpoints_d_exports as CallpointsGuildExpressionsScope, type invites_guild_scope_callpoints_d_exports as CallpointsGuildInvitesScope, type logs_guild_scope_callpoints_d_exports as CallpointsGuildLogsScope, type members_guild_scope_callpoints_d_exports as CallpointsGuildMembersScope, type roles_guild_scope_callpoints_d_exports as CallpointsGuildRolesScope, type lifecycle_message_scope_callpoints_d_exports as CallpointsMessageLifecycleScope, type polls_message_scope_callpoints_d_exports as CallpointsMessagePollsScope, type reactions_message_scope_callpoints_d_exports as CallpointsMessageReactionsScope, type lifecycle_thread_scope_callpoints_d_exports as CallpointsThreadLifecycleScope, type members_thread_scope_callpoints_d_exports as CallpointsThreadMembersScope, type DescriptableEvent, type EventDescription, OriginMap, OriginNamespace, type OriginObject, type client_application_scope_origins_d_exports as OriginsApplicationClientScope, type gateway_application_scope_origins_d_exports as OriginsApplicationGatewayScope, type installations_application_scope_origins_d_exports as OriginsApplicationInstallationsScope, type actions_channel_scope_origins_d_exports as OriginsChannelActionsScope, type lifecycle_channel_scope_origins_d_exports as OriginsChannelLifecycleScope, type stage_channel_scope_origins_d_exports as OriginsChannelStageScope, type voice_channel_scope_origins_d_exports as OriginsChannelVoiceScope, type webhook_channel_scope_origins_d_exports as OriginsChannelWebhookScope, type configuration_guild_scope_origins_d_exports as OriginsGuildConfigurationScope, type events_guild_scope_origins_d_exports as OriginsGuildEventsScope, type expressions_guild_scope_origins_d_exports as OriginsGuildExpressionsScope, type invites_guild_scope_origins_d_exports as OriginsGuildInvitesScope, type logs_guild_scope_origins_d_exports as OriginsGuildLogsScope, type members_guild_scope_origins_d_exports as OriginsGuildMembersScope, type roles_guild_scope_origins_d_exports as OriginsGuildRolesScope, type lifecycle_message_scope_origins_d_exports as OriginsMessageLifecycleScope, type polls_message_scope_origins_d_exports as OriginsMessagePollsScope, type reactions_message_scope_origins_d_exports as OriginsMessageReactionsScope, type lifecycle_thread_scope_origins_d_exports as OriginsThreadLifecycleScope, type members_thread_scope_origins_d_exports as OriginsThreadMembersScope, ProducerKind, parse };
+//# sourceMappingURL=index.d.cts.map