@impulsedev/chameleon 3.5.0 → 3.6.0

package/dist/index.js

@@ -33,7 +33,7 @@ import {
   serializeComponent,
   toCamelCase,
   toSnakeCase
-} from "./chunk-G4SUOXGV.js";
+} from "./chunk-SEC6DGVP.js";
 
 // src/types/user/index.ts
 var UserFlag = {
@@ -887,6 +887,7 @@ var ChameleonREST = class {
         ok: false,
         status: response.status,
         ...typeof errData?.code === "number" ? { code: errData.code } : {},
+        error: typeof errData?.message === "string" ? errData.message : response.statusText,
         message: typeof errData?.message === "string" ? errData.message : response.statusText,
         raw: data
       };
@@ -894,6 +895,7 @@ var ChameleonREST = class {
       return {
         ok: false,
         status: 0,
+        error: error instanceof Error ? error.message : "Unknown network error",
         message: error instanceof Error ? error.message : "Unknown network error"
       };
     }
@@ -958,6 +960,7 @@ var ChameleonREST = class {
         ok: false,
         status: response.status,
         ...typeof errData?.code === "number" ? { code: errData.code } : {},
+        error: typeof errData?.message === "string" ? errData.message : response.statusText,
         message: typeof errData?.message === "string" ? errData.message : response.statusText,
         raw: data
       };
@@ -965,6 +968,7 @@ var ChameleonREST = class {
       return {
         ok: false,
         status: 0,
+        error: error instanceof Error ? error.message : "Unknown network error",
         message: error instanceof Error ? error.message : "Unknown network error"
       };
     }
@@ -1338,7 +1342,7 @@ var ChameleonGateway = class {
 // package.json
 var package_default = {
   name: "@impulsedev/chameleon",
-  version: "3.0.0",
+  version: "3.6.0",
   description: "highly optimized, memory-efficient, and fully type-safe Discord API library",
   main: "dist/index.js",
   types: "dist/index.d.ts",
@@ -1414,6 +1418,12 @@ var CHAMELEON_VERSION = package_default.version;
 var CHAMELEON = package_default.name;
 
 // src/commands/options.ts
+function choice(name, value) {
+  return { name, value };
+}
+function choices(...items) {
+  return items;
+}
 var opt = {
   string: (description, options) => ({
     type: "string",
@@ -1446,12 +1456,317 @@ var opt = {
   channel: (description, options) => ({
     type: "channel",
     description,
-    required: options?.required ?? false
+    required: options?.required ?? false,
+    ...options
   }),
   role: (description, options) => ({
     type: "role",
     description,
     required: options?.required ?? false
+  }),
+  mentionable: (description, options) => ({
+    type: "mentionable",
+    description,
+    required: options?.required ?? false
+  }),
+  attachment: (description, options) => ({
+    type: "attachment",
+    description,
+    required: options?.required ?? false
+  })
+};
+
+// src/components/define.ts
+function resolveButtonStyle(style) {
+  if (typeof style === "number") return style;
+  const map = { primary: 1, secondary: 2, success: 3, danger: 4, link: 5, premium: 6 };
+  return map[style] ?? 1;
+}
+function defineButton(def) {
+  return { ...def, type: "button" };
+}
+var Button = {
+  /** Build a reusable button definition that can be used in both V1 action rows and V2 accessories */
+  of: (def) => defineButton(def),
+  /** @param customId Component custom ID sent back in the interaction payload @param label Visible button text */
+  primary: (customId, label) => defineButton({ customId, label, style: "primary" }),
+  /** @param customId Component custom ID sent back in the interaction payload @param label Visible button text */
+  secondary: (customId, label) => defineButton({ customId, label, style: "secondary" }),
+  /** @param customId Component custom ID sent back in the interaction payload @param label Visible button text */
+  success: (customId, label) => defineButton({ customId, label, style: "success" }),
+  /** @param customId Component custom ID sent back in the interaction payload @param label Visible button text */
+  danger: (customId, label) => defineButton({ customId, label, style: "danger" }),
+  /** @param url Destination URL opened by the button @param label Visible button text */
+  link: (url, label) => defineButton({ url, label, style: "link" }),
+  /** @param skuId Premium SKU ID used by Discord premium buttons @param label Visible button text */
+  premium: (skuId, label) => defineButton({ skuId, label, style: "premium" })
+};
+function defineStringSelect(def) {
+  return { ...def, type: "string_select" };
+}
+function defineUserSelect(def) {
+  return { ...def, type: "user_select" };
+}
+function defineRoleSelect(def) {
+  return { ...def, type: "role_select" };
+}
+function defineChannelSelect(def) {
+  return { ...def, type: "channel_select" };
+}
+function defineMentionableSelect(def) {
+  return { ...def, type: "mentionable_select" };
+}
+var field = {
+  /**
+   * Create a single-line text input field for a modal
+   * @param id Field ID used as the key inside `ctx.fields`
+   * @param label Visible field label shown in the modal
+   * @param options Extra validation and UX settings for the text input
+   */
+  short: (id, label, options) => ({
+    id,
+    type: 1 /* SHORT */,
+    label,
+    required: options?.required ?? true,
+    ...options
+  }),
+  /**
+   * Create a multi-line text input field for a modal
+   * @param id Field ID used as the key inside `ctx.fields`
+   * @param label Visible field label shown in the modal
+   * @param options Extra validation and UX settings for the paragraph input
+   */
+  paragraph: (id, label, options) => ({
+    id,
+    type: 2 /* PARAGRAPH */,
+    label,
+    required: options?.required ?? true,
+    ...options
+  }),
+  /**
+   * Create a boolean checkbox field for a modal
+   * @param id Field ID used as the key inside `ctx.fields`
+   * @param label Visible field label shown in the modal
+   * @param options Checkbox settings such as `required` and default `value`
+   */
+  checkbox: (id, label, options) => ({
+    id,
+    type: 23,
+    label,
+    required: options?.required ?? true,
+    ...options
+  }),
+  /**
+   * Create a multi-select checkbox group field for a modal
+   * @param id Field ID used as the key inside `ctx.fields`
+   * @param label Visible field label shown in the modal
+   * @param options Available choices and selection limits
+   */
+  checkboxGroup: (id, label, options) => ({
+    id,
+    type: 22,
+    label,
+    required: options?.required ?? true,
+    ...options
+  }),
+  /**
+   * Create a single-choice radio group field for a modal
+   * @param id Field ID used as the key inside `ctx.fields`
+   * @param label Visible field label shown in the modal
+   * @param options Available choices for the radio group
+   */
+  radioGroup: (id, label, options) => ({
+    id,
+    type: 21,
+    label,
+    required: options?.required ?? true,
+    ...options
+  }),
+  /**
+   * Create a file upload field for a modal
+   * Submitted files are available in `ctx.attachments[id]`
+   * @param id Field ID used as the key inside `ctx.fields` and `ctx.attachments`
+   * @param label Visible field label shown in the modal
+   * @param options Upload field settings such as `required`
+   */
+  fileUpload: (id, label, options) => ({
+    id,
+    type: 19,
+    label,
+    required: options?.required ?? true,
+    ...options
+  })
+};
+function defineModal(def) {
+  return { ...def, type: "modal" };
+}
+var ModalDefinitionBuilder = class _ModalDefinitionBuilder {
+  constructor(customId, title, fieldsDef = []) {
+    this.customId = customId;
+    this.title = title;
+    this.fieldsDef = fieldsDef;
+  }
+  customId;
+  title;
+  fieldsDef;
+  /**
+   * Append one or more fields to the modal definition
+   * The resulting builder keeps full type information, so added field IDs become available in `ctx.fields`
+   * @param fields Fields to add to the modal
+   */
+  add(...fields) {
+    return new _ModalDefinitionBuilder(
+      this.customId,
+      this.title,
+      [...this.fieldsDef, ...fields]
+    );
+  }
+  /**
+   * Finalize the modal definition and attach its submit handler
+   * The handler receives a strongly-typed `ctx.fields` object derived from the fields added to this builder
+   * @param execute Modal submit handler
+   */
+  execute(execute) {
+    return defineModal({
+      customId: this.customId,
+      title: this.title,
+      fields: this.fieldsDef,
+      execute
+    });
+  }
+  handle(execute) {
+    return this.execute(execute);
+  }
+};
+function modal(customId, title) {
+  return new ModalDefinitionBuilder(customId, title);
+}
+
+// src/components/v2.ts
+function serializeV2Button(button) {
+  const obj = {
+    type: 2 /* BUTTON */,
+    custom_id: button.customId,
+    url: button.url,
+    label: button.label,
+    style: resolveButtonStyle(button.style),
+    disabled: button.disabled,
+    emoji: button.emoji,
+    sku_id: button.skuId
+  };
+  return Object.fromEntries(Object.entries(obj).filter(([, value]) => value !== void 0));
+}
+function normalizeV2Component(component) {
+  if (component && typeof component === "object" && "type" in component && component.type === "button") {
+    return serializeV2Button(component);
+  }
+  if (component && typeof component.toJSON === "function") {
+    return component.toJSON();
+  }
+  return component;
+}
+function serializeModalFieldComponent(field2) {
+  return {
+    type: field2.type === 1 /* SHORT */ || field2.type === 2 /* PARAGRAPH */ ? 4 /* TEXT_INPUT */ : field2.type,
+    custom_id: field2.id,
+    required: field2.required,
+    style: field2.type === 1 /* SHORT */ || field2.type === 2 /* PARAGRAPH */ ? field2.type : void 0,
+    min_length: field2.minLength,
+    max_length: field2.maxLength,
+    placeholder: field2.placeholder,
+    value: field2.value,
+    options: field2.options,
+    min_values: field2.minValues,
+    max_values: field2.maxValues
+  };
+}
+var SectionBuilder = class {
+  data;
+  constructor(components, accessory) {
+    this.data = {
+      type: 9 /* SECTION */,
+      components
+    };
+    if (accessory) {
+      this.data.accessory = accessory;
+    }
+  }
+  accessory(accessory) {
+    this.data.accessory = accessory;
+    return this;
+  }
+  toJSON() {
+    return {
+      ...this.data,
+      components: this.data.components.map((component) => normalizeV2Component(component)),
+      ...this.data.accessory ? { accessory: normalizeV2Component(this.data.accessory) } : {}
+    };
+  }
+};
+var TextDisplay = {
+  of: (content) => ({
+    type: 10 /* TEXT_DISPLAY */,
+    content
+  })
+};
+var Thumbnail = {
+  of: (url, description, spoiler) => ({
+    type: 11 /* THUMBNAIL */,
+    media: { url },
+    description,
+    spoiler
+  })
+};
+var Separator = {
+  of: (spacing, divider) => ({
+    type: 14 /* SEPARATOR */,
+    spacing,
+    divider
+  })
+};
+var Section = {
+  /**
+   * Section builder
+   * @param components Child components rendered inside the section body
+   * @param accessory Optional accessory rendered on the side of the section
+   */
+  of: (components, accessory) => {
+    return new SectionBuilder(components, accessory);
+  },
+  /** @param content Text rendered as a single TextDisplay inside the section */
+  text: (content) => {
+    return Section.of([TextDisplay.of(content)]);
+  }
+};
+var Container = {
+  /**
+   * Container builder
+   * @param components Child components rendered inside the container
+   * @param spoiler Whether the container should be hidden behind a spoiler
+   */
+  of: (components, spoiler) => {
+    const obj = {
+      type: 17 /* CONTAINER */,
+      components
+    };
+    if (spoiler !== void 0) {
+      obj.spoiler = spoiler;
+    }
+    return obj;
+  },
+  /** Helper for stacking V2 components vertically without manually creating an array */
+  stack: (...components) => {
+    return Container.of(components);
+  }
+};
+var Label = {
+  /** Wrap a modal field component in a V2 label container */
+  of: (field2) => ({
+    type: 18 /* LABEL */,
+    label: field2.label,
+    component: Object.fromEntries(
+      Object.entries(serializeModalFieldComponent(field2)).filter(([, value]) => value !== void 0)
+    )
   })
 };
 
@@ -1473,12 +1788,21 @@ var BaseInteractionContext = class {
     this.guild = guild;
     this.channel = channel;
   }
+  get client() {
+    return this._client;
+  }
   get replied() {
     return this._replied;
   }
   get deferred() {
     return this._deferred;
   }
+  _assertOk(result, action) {
+    if (result.ok) return;
+    const details = result.message ? `: ${result.message}` : "";
+    const raw = result.raw !== void 0 ? ` | raw=${JSON.stringify(result.raw)}` : "";
+    throw new Error(`Discord rejected interaction ${action}${details}${raw}`);
+  }
   _resolvePayload(payload) {
     const data = typeof payload === "string" ? { content: payload } : { ...payload };
     if (typeof payload === "object") {
@@ -1497,52 +1821,46 @@ var BaseInteractionContext = class {
     }
     return data;
   }
+  _serializeModalField(field2) {
+    return Label.of(field2);
+  }
   async reply(payload) {
     if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
     const data = this._resolvePayload(payload);
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+    const result = await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
       type: 4 /* CHANNEL_MESSAGE_WITH_SOURCE */,
       data
     });
+    this._assertOk(result, "reply");
     this._replied = true;
   }
   async defer(options) {
     if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+    const result = await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
       type: 5 /* DEFERRED_CHANNEL_MESSAGE_WITH_SOURCE */,
       data: { flags: options?.ephemeral ? MESSAGE_FLAGS.EPHEMERAL : 0 }
     });
+    this._assertOk(result, "defer");
     this._deferred = true;
   }
   async followUp(payload) {
     if (!this._deferred && !this._replied) throw new Error("Interaction not acknowledged.");
     const data = this._resolvePayload(payload);
-    await this._client.rest.post(`/webhooks/${this._client.user?.id}/${this.interactionToken}`, data);
+    const result = await this._client.rest.post(`/webhooks/${this._client.user?.id}/${this.interactionToken}`, data);
+    this._assertOk(result, "followUp");
   }
-  async showModal(modal) {
+  async showModal(modal2) {
     if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    const payload = modal.type === "modal" ? {
-      custom_id: modal.customId,
-      title: modal.title,
-      components: Array.isArray(modal.fields) ? modal.fields.map((f) => ({
-        type: 1 /* ACTION_ROW */,
-        components: [{
-          type: 4 /* TEXT_INPUT */,
-          custom_id: f.id,
-          style: f.type,
-          label: f.label,
-          required: f.required,
-          min_length: f.minLength,
-          max_length: f.maxLength,
-          placeholder: f.placeholder,
-          value: f.value
-        }]
-      })) : []
-    } : modal;
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+    const payload = modal2.type === "modal" ? {
+      custom_id: modal2.customId,
+      title: modal2.title,
+      components: Array.isArray(modal2.fields) ? modal2.fields.map((f) => this._serializeModalField(f)) : []
+    } : modal2;
+    const result = await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
       type: 9 /* MODAL */,
       data: payload
     });
+    this._assertOk(result, "showModal");
     this._replied = true;
   }
 };
@@ -1554,32 +1872,457 @@ var CommandContext = class extends BaseInteractionContext {
   }
 };
 
+// src/utils/bitfield.ts
+var BitField = class _BitField {
+  static FLAGS = {};
+  bitfield;
+  constructor(bits = 0n) {
+    this.bitfield = this.constructor.resolve(bits);
+  }
+  has(bit) {
+    const resolved = this.constructor.resolve(bit);
+    return (this.bitfield & resolved) === resolved;
+  }
+  any(bit) {
+    const resolved = this.constructor.resolve(bit);
+    return (this.bitfield & resolved) !== 0n;
+  }
+  add(...bits) {
+    let total = 0n;
+    for (const bit of bits) {
+      total |= this.constructor.resolve(bit);
+    }
+    this.bitfield |= total;
+    return this;
+  }
+  remove(...bits) {
+    let total = 0n;
+    for (const bit of bits) {
+      total |= this.constructor.resolve(bit);
+    }
+    this.bitfield &= ~total;
+    return this;
+  }
+  toArray() {
+    const flags = this.constructor.FLAGS;
+    return Object.keys(flags).filter((flag) => this.has(flags[flag]));
+  }
+  serialize() {
+    const flags = this.constructor.FLAGS;
+    const result = {};
+    for (const [flag, value] of Object.entries(flags)) {
+      result[flag] = this.has(value);
+    }
+    return result;
+  }
+  equals(other) {
+    return this.bitfield === this.constructor.resolve(other);
+  }
+  freeze() {
+    return Object.freeze(this);
+  }
+  toString() {
+    return this.bitfield.toString();
+  }
+  toJSON() {
+    return this.toString();
+  }
+  static resolve(bit) {
+    if (typeof bit === "bigint") return bit;
+    if (typeof bit === "number") return BigInt(bit);
+    if (bit instanceof _BitField) return bit.bitfield;
+    if (typeof bit === "string") {
+      const flag = this.FLAGS[bit];
+      if (flag !== void 0) return flag;
+      const parsed = BigInt(bit);
+      return parsed;
+    }
+    if (Array.isArray(bit)) {
+      return bit.reduce((acc, b) => acc | this.resolve(b), 0n);
+    }
+    throw new TypeError(`Cannot resolve BitField from: ${bit}`);
+  }
+};
+
+// src/types/permissions.ts
+var PermissionsBitField = class _PermissionsBitField extends BitField {
+  static FLAGS = { ...DISCORD_PERMISSIONS };
+  static ALL = Object.values(DISCORD_PERMISSIONS).reduce((a, b) => a | b, 0n);
+  get isAdmin() {
+    return this.has("ADMINISTRATOR");
+  }
+  static from(bits) {
+    return new _PermissionsBitField(bits);
+  }
+};
+var UserFlagsBitField = class extends BitField {
+  static FLAGS = {
+    STAFF: 1n << 0n,
+    PARTNER: 1n << 1n,
+    HYPESQUAD: 1n << 2n,
+    BUG_HUNTER_LEVEL_1: 1n << 3n,
+    HYPESQUAD_ONLINE_HOUSE_1: 1n << 6n,
+    HYPESQUAD_ONLINE_HOUSE_2: 1n << 7n,
+    HYPESQUAD_ONLINE_HOUSE_3: 1n << 8n,
+    PREMIUM_EARLY_SUPPORTER: 1n << 9n,
+    TEAM_PSEUDO_USER: 1n << 10n,
+    BUG_HUNTER_LEVEL_2: 1n << 14n,
+    VERIFIED_BOT: 1n << 16n,
+    VERIFIED_DEVELOPER: 1n << 17n,
+    CERTIFIED_MODERATOR: 1n << 18n,
+    BOT_HTTP_INTERACTIONS: 1n << 19n,
+    ACTIVE_DEVELOPER: 1n << 22n
+  };
+};
+var IntentsBitField = class extends BitField {
+  static FLAGS = {
+    Guilds: 1n << 0n,
+    GuildMembers: 1n << 1n,
+    GuildModeration: 1n << 2n,
+    GuildEmojisAndStickers: 1n << 3n,
+    GuildIntegrations: 1n << 4n,
+    GuildWebhooks: 1n << 5n,
+    GuildInvites: 1n << 6n,
+    GuildVoiceStates: 1n << 7n,
+    GuildPresences: 1n << 8n,
+    GuildMessages: 1n << 9n,
+    GuildMessageReactions: 1n << 10n,
+    GuildMessageTyping: 1n << 11n,
+    DirectMessages: 1n << 12n,
+    DirectMessageReactions: 1n << 13n,
+    DirectMessageTyping: 1n << 14n,
+    MessageContent: 1n << 15n,
+    GuildScheduledEvents: 1n << 16n,
+    AutoModerationConfiguration: 1n << 20n,
+    AutoModerationExecution: 1n << 21n,
+    GuildMessagePolls: 1n << 24n,
+    DirectMessagePolls: 1n << 25n
+  };
+};
+function computeBasePermissions(member, guild) {
+  if (member.roles === void 0) return 0n;
+  const userId = member.user?.id;
+  if (userId && userId === guild.ownerId) return PermissionsBitField.ALL;
+  const everyoneRole = guild.roles.find((r) => r.id === guild.id);
+  let permissions = everyoneRole ? BigInt(everyoneRole.permissions) : 0n;
+  for (const roleId of member.roles) {
+    const role = guild.roles.find((r) => r.id === roleId);
+    if (role) permissions |= BigInt(role.permissions);
+  }
+  if ((permissions & DISCORD_PERMISSIONS.ADMINISTRATOR) === DISCORD_PERMISSIONS.ADMINISTRATOR) {
+    return PermissionsBitField.ALL;
+  }
+  return permissions;
+}
+function computeChannelPermissions(basePermissions, overwrites, memberRoles, memberId) {
+  if ((basePermissions & DISCORD_PERMISSIONS.ADMINISTRATOR) === DISCORD_PERMISSIONS.ADMINISTRATOR) {
+    return PermissionsBitField.ALL;
+  }
+  let permissions = basePermissions;
+  let allow = 0n;
+  let deny = 0n;
+  for (const overwrite of overwrites) {
+    if (overwrite.type === 0) {
+      if (memberRoles.includes(overwrite.id) || overwrites.indexOf(overwrite) === 0) {
+        if (overwrites.indexOf(overwrite) === 0 && !memberRoles.includes(overwrite.id)) {
+          permissions &= ~BigInt(overwrite.deny);
+          permissions |= BigInt(overwrite.allow);
+        } else {
+          allow |= BigInt(overwrite.allow);
+          deny |= BigInt(overwrite.deny);
+        }
+      }
+    }
+  }
+  permissions &= ~deny;
+  permissions |= allow;
+  if (memberId) {
+    const memberOverwrite = overwrites.find((ow) => ow.type === 1 && ow.id === memberId);
+    if (memberOverwrite) {
+      permissions &= ~BigInt(memberOverwrite.deny);
+      permissions |= BigInt(memberOverwrite.allow);
+    }
+  }
+  return permissions;
+}
+
 // src/commands/command.ts
 function defineSubcommand(def) {
   return def;
 }
+function defineSubcommandGroup(def) {
+  return def;
+}
 function defineCommand(def) {
   if (!def.execute && (!def.subcommands || Object.keys(def.subcommands).length === 0)) {
     throw new Error(`Command ${def.name} must have an execute function or subcommands.`);
   }
   return def;
 }
+function appendOption(optionsDef, name, definition) {
+  return {
+    ...optionsDef ?? {},
+    [name]: definition
+  };
+}
+function normalizeChoicesOptions(choicesOrOptions, maybeOptions) {
+  if (Array.isArray(choicesOrOptions)) {
+    return {
+      ...maybeOptions ?? {},
+      choices: choicesOrOptions
+    };
+  }
+  if (choicesOrOptions) {
+    return choicesOrOptions;
+  }
+  return void 0;
+}
+var SubcommandDefinitionBuilder = class _SubcommandDefinitionBuilder {
+  constructor(description, optionsDef) {
+    this.description = description;
+    this.optionsDef = optionsDef;
+  }
+  description;
+  optionsDef;
+  options(options) {
+    return new _SubcommandDefinitionBuilder(this.description, options);
+  }
+  option(name, definition) {
+    return new _SubcommandDefinitionBuilder(
+      this.description,
+      appendOption(this.optionsDef, name, definition)
+    );
+  }
+  string(name, description, choicesOrOptions, maybeOptions) {
+    return this.option(name, opt.string(description, normalizeChoicesOptions(choicesOrOptions, maybeOptions)));
+  }
+  integer(name, description, choicesOrOptions, maybeOptions) {
+    return this.option(name, opt.integer(description, normalizeChoicesOptions(choicesOrOptions, maybeOptions)));
+  }
+  number(name, description, choicesOrOptions, maybeOptions) {
+    return this.option(name, opt.number(description, normalizeChoicesOptions(choicesOrOptions, maybeOptions)));
+  }
+  boolean(name, description, options) {
+    return this.option(name, opt.boolean(description, options));
+  }
+  user(name, description, options) {
+    return this.option(name, opt.user(description, options));
+  }
+  channel(name, description, options) {
+    return this.option(name, opt.channel(description, options));
+  }
+  role(name, description, options) {
+    return this.option(name, opt.role(description, options));
+  }
+  mentionable(name, description, options) {
+    return this.option(name, opt.mentionable(description, options));
+  }
+  attachment(name, description, options) {
+    return this.option(name, opt.attachment(description, options));
+  }
+  execute(execute) {
+    return defineSubcommand({
+      description: this.description,
+      ...this.optionsDef ? { options: this.optionsDef } : {},
+      execute
+    });
+  }
+  handle(execute) {
+    return this.execute(execute);
+  }
+};
+var SubcommandGroupDefinitionBuilder = class _SubcommandGroupDefinitionBuilder {
+  constructor(description, subcommandsDef) {
+    this.description = description;
+    this.subcommandsDef = subcommandsDef;
+  }
+  description;
+  subcommandsDef;
+  subcommands(subcommands) {
+    return new _SubcommandGroupDefinitionBuilder(this.description, subcommands);
+  }
+  subcommand(name, subcommand2) {
+    return new _SubcommandGroupDefinitionBuilder(
+      this.description,
+      {
+        ...this.subcommandsDef ?? {},
+        [name]: subcommand2
+      }
+    );
+  }
+  toGroup() {
+    return defineSubcommandGroup({
+      description: this.description,
+      subcommands: this.subcommandsDef ?? {}
+    });
+  }
+  build() {
+    return this.toGroup();
+  }
+};
+var CommandDefinitionBuilder = class _CommandDefinitionBuilder {
+  constructor(name, description, optionsDef, subcommandsDef, metadata = {}) {
+    this.name = name;
+    this.description = description;
+    this.optionsDef = optionsDef;
+    this.subcommandsDef = subcommandsDef;
+    this.metadata = metadata;
+  }
+  name;
+  description;
+  optionsDef;
+  subcommandsDef;
+  metadata;
+  options(options) {
+    return new _CommandDefinitionBuilder(this.name, this.description, options, this.subcommandsDef, this.metadata);
+  }
+  option(name, definition) {
+    return new _CommandDefinitionBuilder(
+      this.name,
+      this.description,
+      appendOption(this.optionsDef, name, definition),
+      this.subcommandsDef,
+      this.metadata
+    );
+  }
+  string(name, description, choicesOrOptions, maybeOptions) {
+    return this.option(name, opt.string(description, normalizeChoicesOptions(choicesOrOptions, maybeOptions)));
+  }
+  integer(name, description, choicesOrOptions, maybeOptions) {
+    return this.option(name, opt.integer(description, normalizeChoicesOptions(choicesOrOptions, maybeOptions)));
+  }
+  number(name, description, choicesOrOptions, maybeOptions) {
+    return this.option(name, opt.number(description, normalizeChoicesOptions(choicesOrOptions, maybeOptions)));
+  }
+  boolean(name, description, options) {
+    return this.option(name, opt.boolean(description, options));
+  }
+  user(name, description, options) {
+    return this.option(name, opt.user(description, options));
+  }
+  channel(name, description, options) {
+    return this.option(name, opt.channel(description, options));
+  }
+  role(name, description, options) {
+    return this.option(name, opt.role(description, options));
+  }
+  mentionable(name, description, options) {
+    return this.option(name, opt.mentionable(description, options));
+  }
+  attachment(name, description, options) {
+    return this.option(name, opt.attachment(description, options));
+  }
+  subcommands(subcommands) {
+    return new _CommandDefinitionBuilder(this.name, this.description, this.optionsDef, subcommands, this.metadata);
+  }
+  subcommand(name, subcommand2) {
+    return new _CommandDefinitionBuilder(
+      this.name,
+      this.description,
+      this.optionsDef,
+      {
+        ...this.subcommandsDef ?? {},
+        [name]: subcommand2
+      },
+      this.metadata
+    );
+  }
+  group(name, group) {
+    const normalized = typeof group.toGroup === "function" ? group.toGroup() : group;
+    return new _CommandDefinitionBuilder(
+      this.name,
+      this.description,
+      this.optionsDef,
+      {
+        ...this.subcommandsDef ?? {},
+        [name]: normalized
+      },
+      this.metadata
+    );
+  }
+  setPermissions(permissions) {
+    return new _CommandDefinitionBuilder(
+      this.name,
+      this.description,
+      this.optionsDef,
+      this.subcommandsDef,
+      {
+        ...this.metadata,
+        defaultMemberPermissions: permissions === null ? null : PermissionsBitField.resolve(permissions).toString()
+      }
+    );
+  }
+  setDefaultMemberPermissions(permissions) {
+    return this.setPermissions(permissions);
+  }
+  execute(execute) {
+    return defineCommand({
+      name: this.name,
+      description: this.description,
+      ...this.optionsDef ? { options: this.optionsDef } : {},
+      ...this.subcommandsDef ? { subcommands: this.subcommandsDef } : {},
+      ...this.metadata.defaultMemberPermissions !== void 0 ? { defaultMemberPermissions: this.metadata.defaultMemberPermissions } : {},
+      execute
+    });
+  }
+  handle(execute) {
+    return this.execute(execute);
+  }
+  toCommand() {
+    return defineCommand({
+      name: this.name,
+      description: this.description,
+      ...this.optionsDef ? { options: this.optionsDef } : {},
+      ...this.subcommandsDef ? { subcommands: this.subcommandsDef } : {},
+      ...this.metadata.defaultMemberPermissions !== void 0 ? { defaultMemberPermissions: this.metadata.defaultMemberPermissions } : {}
+    });
+  }
+  build() {
+    return this.toCommand();
+  }
+};
+function command(name, description) {
+  return new CommandDefinitionBuilder(name, description);
+}
+function subcommand(description) {
+  return new SubcommandDefinitionBuilder(description);
+}
+function subcommandGroup(description) {
+  return new SubcommandGroupDefinitionBuilder(description);
+}
 
 // src/commands/interactions.ts
 var ModalContext = class extends BaseInteractionContext {
   customId;
+  attachments = {};
   _fields = /* @__PURE__ */ new Map();
   constructor(client, raw, user, guild, channel) {
     super(client, raw, user, guild, channel);
-    this.customId = raw.data?.custom_id ?? "";
-    const rows = raw.data?.components ?? [];
-    for (const row of rows) {
-      for (const comp of row.components ?? []) {
-        if (comp.custom_id && comp.value !== void 0) {
-          this._fields.set(comp.custom_id, comp.value);
+    const data = raw.data ?? {};
+    this.customId = data.custom_id ?? "";
+    const rows = data.components ?? [];
+    const resolvedAttachments = data.resolved?.attachments ?? {};
+    const extractFields = (components) => {
+      for (const comp of components) {
+        if (comp.custom_id) {
+          if (comp.values !== void 0) {
+            this._fields.set(comp.custom_id, comp.values);
+            if (Array.isArray(comp.values)) {
+              this.attachments[comp.custom_id] = comp.values.map((id) => resolvedAttachments[id]).filter((attachment) => attachment !== void 0);
+            }
+          } else if (comp.value !== void 0) {
+            this._fields.set(comp.custom_id, comp.value);
+          }
+        }
+        if (Array.isArray(comp.components)) {
+          extractFields(comp.components);
+        }
+        if (comp.component && typeof comp.component === "object") {
+          extractFields([comp.component]);
         }
       }
-    }
+    };
+    extractFields(rows);
   }
   // Get a text input value by its customId
   // values from a select menu interaction
@@ -1608,28 +2351,43 @@ var ComponentContext = class extends BaseInteractionContext {
     this.values = data?.values ?? [];
     const fields = {};
     if (data?.components) {
-      for (const row of data.components) {
-        for (const comp of row.components) {
-          fields[comp.custom_id] = comp.value;
+      const extractFields = (components) => {
+        for (const comp of components) {
+          if (comp.custom_id !== void 0) {
+            if (comp.values !== void 0) {
+              fields[comp.custom_id] = comp.values;
+            } else if (comp.value !== void 0) {
+              fields[comp.custom_id] = comp.value;
+            }
+          }
+          if (comp.components) {
+            extractFields(comp.components);
+          }
+          if (comp.component) {
+            extractFields([comp.component]);
+          }
         }
-      }
+      };
+      extractFields(data.components);
     }
     this.fields = fields;
   }
   async deferUpdate() {
     if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+    const result = await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
       type: 6 /* DEFERRED_UPDATE_MESSAGE */
     });
+    this._assertOk(result, "deferUpdate");
     this._deferred = true;
   }
   async update(payload) {
     if (this._replied || this._deferred) throw new Error("Interaction already acknowledged.");
     const data = this._resolvePayload(payload);
-    await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
+    const result = await this._client.rest.post(`/interactions/${this.interactionId}/${this.interactionToken}/callback`, {
       type: 7 /* UPDATE_MESSAGE */,
       data
     });
+    this._assertOk(result, "update");
     this._replied = true;
   }
 };
@@ -1637,6 +2395,9 @@ var ComponentContext = class extends BaseInteractionContext {
 // src/commands/manager.ts
 import * as fs from "fs";
 import * as path from "path";
+function isSubcommandGroup(candidate) {
+  return "subcommands" in candidate;
+}
 var CommandManager = class {
   _commands = /* @__PURE__ */ new Map();
   _components = [];
@@ -1646,16 +2407,18 @@ var CommandManager = class {
     this._client = client;
   }
   register(...commands) {
-    for (const cmd of commands) {
+    const normalized = commands.map((cmd) => this._normalizeCommand(cmd));
+    for (const cmd of normalized) {
       this._commands.set(cmd.name, cmd);
     }
-    this._deployCommands(commands).catch(console.error);
+    this._deployCommands(normalized).catch(console.error);
   }
   registerGuild(guildId, ...commands) {
-    for (const cmd of commands) {
+    const normalized = commands.map((cmd) => this._normalizeCommand(cmd));
+    for (const cmd of normalized) {
       this._commands.set(cmd.name, cmd);
     }
-    this._deployCommands(commands, guildId).catch(console.error);
+    this._deployCommands(normalized, guildId).catch(console.error);
   }
   registerComponent(handler) {
     this._components.push(handler);
@@ -1675,9 +2438,9 @@ var CommandManager = class {
       const filePath = path.join(fullPath, file);
       try {
         const module = await import(`file://${filePath}`);
-        const command = module.default;
-        if (command && typeof command.name === "string") {
-          commands.push(command);
+        const command2 = module.default;
+        if (command2 && (typeof command2.name === "string" || typeof command2.toCommand === "function")) {
+          commands.push(command2);
         }
       } catch (err) {
         console.error(`[Chameleon] Failed to load command from ${file}:`, err);
@@ -1714,15 +2477,54 @@ var CommandManager = class {
           return 7;
         case "role":
           return 8;
+        case "mentionable":
+          return 9;
         case "number":
           return 10;
+        case "attachment":
+          return 11;
         default:
           return 3;
       }
     };
     const options = [];
     if (cmd.subcommands) {
-      for (const [subName, subDef] of Object.entries(cmd.subcommands)) {
+      for (const [subName, subDefRaw] of Object.entries(cmd.subcommands)) {
+        const candidate = subDefRaw;
+        if (isSubcommandGroup(candidate)) {
+          const nested = Object.entries(candidate.subcommands).map(([nestedName, nestedDefRaw]) => {
+            const nestedDef = nestedDefRaw;
+            const nestedOptions = nestedDef.options ? Object.entries(nestedDef.options).map(([optName, optDefRaw]) => {
+              const optDef = optDefRaw;
+              return {
+                type: mapType(optDef.type),
+                name: optName,
+                description: optDef.description,
+                required: optDef.required,
+                choices: optDef.choices,
+                channel_types: optDef.channelTypes,
+                min_value: optDef.min,
+                max_value: optDef.max,
+                min_length: optDef.minLength,
+                max_length: optDef.maxLength
+              };
+            }) : [];
+            return {
+              type: 1 /* SUB_COMMAND */,
+              name: nestedName,
+              description: nestedDef.description,
+              options: nestedOptions
+            };
+          });
+          options.push({
+            type: 2 /* SUB_COMMAND_GROUP */,
+            name: subName,
+            description: candidate.description,
+            options: nested
+          });
+          continue;
+        }
+        const subDef = candidate;
         const subOpts = [];
         if (subDef.options) {
           for (const [optName, optDefRaw] of Object.entries(subDef.options)) {
@@ -1733,8 +2535,11 @@ var CommandManager = class {
               description: optDef.description,
               required: optDef.required,
               choices: optDef.choices,
+              channel_types: optDef.channelTypes,
               min_value: optDef.min,
-              max_value: optDef.max
+              max_value: optDef.max,
+              min_length: optDef.minLength,
+              max_length: optDef.maxLength
             });
           }
         }
@@ -1754,17 +2559,27 @@ var CommandManager = class {
           description: optDef.description,
           required: optDef.required,
           choices: optDef.choices,
+          channel_types: optDef.channelTypes,
           min_value: optDef.min,
-          max_value: optDef.max
+          max_value: optDef.max,
+          min_length: optDef.minLength,
+          max_length: optDef.maxLength
         });
       }
     }
     return {
       name: cmd.name,
       description: cmd.description,
+      default_member_permissions: cmd.defaultMemberPermissions ?? void 0,
       options: options.length ? options : void 0
     };
   }
+  _normalizeCommand(command2) {
+    if (typeof command2.toCommand === "function") {
+      return command2.toCommand();
+    }
+    return command2;
+  }
   async handleInteraction(raw) {
     const data = raw.data;
     if (!data) return;
@@ -1773,17 +2588,29 @@ var CommandManager = class {
     if (raw.type !== 2 /* APPLICATION_COMMAND */) return;
     const name = data.name;
     if (!name) return;
-    const command = this._commands.get(name);
-    if (!command) return;
+    const command2 = this._commands.get(name);
+    if (!command2) return;
     const parsedOptions = {};
-    let targetExecute = command.execute;
+    let targetExecute = command2.execute;
     const rawOptions = data.options || [];
     let actualOptions = rawOptions;
-    if (rawOptions.length > 0 && rawOptions[0].type === 1 /* SUB_COMMAND */) {
+    if (rawOptions.length > 0 && rawOptions[0].type === 2 /* SUB_COMMAND_GROUP */) {
+      const groupName = rawOptions[0].name;
+      const groupOption = rawOptions[0];
+      const nestedSubcommand = groupOption.options?.[0];
+      if (nestedSubcommand) {
+        actualOptions = nestedSubcommand.options || [];
+        const group = command2.subcommands?.[groupName];
+        const targetSubcommand = group?.subcommands?.[nestedSubcommand.name];
+        if (targetSubcommand) {
+          targetExecute = targetSubcommand.execute;
+        }
+      }
+    } else if (rawOptions.length > 0 && rawOptions[0].type === 1 /* SUB_COMMAND */) {
       const subcommandName = rawOptions[0].name;
       actualOptions = rawOptions[0].options || [];
-      if (command.subcommands && command.subcommands[subcommandName]) {
-        targetExecute = command.subcommands[subcommandName].execute;
+      if (command2.subcommands && command2.subcommands[subcommandName]) {
+        targetExecute = command2.subcommands[subcommandName].execute;
       }
     }
     for (const opt2 of actualOptions) {
@@ -1793,6 +2620,16 @@ var CommandManager = class {
         parsedOptions[opt2.name] = resolveChannel(opt2.value, this._client);
       } else if (opt2.type === 8 /* ROLE */ && data.resolved?.roles?.[opt2.value]) {
         parsedOptions[opt2.name] = resolveRole(opt2.value, this._client, raw.guild_id);
+      } else if (opt2.type === 9 /* MENTIONABLE */) {
+        if (data.resolved?.users?.[opt2.value]) {
+          parsedOptions[opt2.name] = resolveUser(opt2.value, this._client);
+        } else if (data.resolved?.roles?.[opt2.value]) {
+          parsedOptions[opt2.name] = resolveRole(opt2.value, this._client, raw.guild_id);
+        } else {
+          parsedOptions[opt2.name] = opt2.value;
+        }
+      } else if (opt2.type === 11 /* ATTACHMENT */ && data.resolved?.attachments?.[opt2.value]) {
+        parsedOptions[opt2.name] = data.resolved.attachments[opt2.value];
       } else {
         parsedOptions[opt2.name] = opt2.value;
       }
@@ -1863,50 +2700,6 @@ var CommandManager = class {
   }
 };
 
-// src/components/define.ts
-function resolveButtonStyle(style) {
-  if (typeof style === "number") return style;
-  const map = { primary: 1, secondary: 2, success: 3, danger: 4, link: 5, premium: 6 };
-  return map[style] ?? 1;
-}
-function defineButton(def) {
-  return { ...def, type: "button" };
-}
-function defineStringSelect(def) {
-  return { ...def, type: "string_select" };
-}
-function defineUserSelect(def) {
-  return { ...def, type: "user_select" };
-}
-function defineRoleSelect(def) {
-  return { ...def, type: "role_select" };
-}
-function defineChannelSelect(def) {
-  return { ...def, type: "channel_select" };
-}
-function defineMentionableSelect(def) {
-  return { ...def, type: "mentionable_select" };
-}
-var field = {
-  short: (id, label, options) => ({
-    id,
-    type: 1 /* SHORT */,
-    label,
-    required: options?.required ?? true,
-    ...options
-  }),
-  paragraph: (id, label, options) => ({
-    id,
-    type: 2 /* PARAGRAPH */,
-    label,
-    required: options?.required ?? true,
-    ...options
-  })
-};
-function defineModal(def) {
-  return { ...def, type: "modal" };
-}
-
 // src/components/actionRow.ts
 var ActionRow = {
   of: (...components) => {
@@ -1968,6 +2761,38 @@ var ActionRow = {
             value: field2.value
           };
         }
+        if ("type" in c && c.type === 23 /* CHECKBOX */) {
+          const field2 = c;
+          return {
+            type: 23 /* CHECKBOX */,
+            custom_id: field2.id,
+            label: field2.label,
+            required: field2.required,
+            value: field2.value
+          };
+        }
+        if ("type" in c && c.type === 21 /* RADIO_GROUP */) {
+          const field2 = c;
+          return {
+            type: 21 /* RADIO_GROUP */,
+            custom_id: field2.id,
+            label: field2.label,
+            required: field2.required,
+            options: field2.options
+          };
+        }
+        if ("type" in c && c.type === 22 /* CHECKBOX_GROUP */) {
+          const field2 = c;
+          return {
+            type: 22 /* CHECKBOX_GROUP */,
+            custom_id: field2.id,
+            label: field2.label,
+            required: field2.required,
+            min_values: field2.minValues,
+            max_values: field2.maxValues,
+            options: field2.options
+          };
+        }
         return c;
       }).map((obj) => {
         const clean = {};
@@ -2074,7 +2899,7 @@ var UserManager = class extends BaseManager {
   async createDM(userId) {
     const result = await this.rest.post("/users/@me/channels", { recipient_id: userId });
     if (!result.ok) return result;
-    return { ok: true, data: (await import("./builders-WHD6LQWX.js")).buildChannel(result.data) };
+    return { ok: true, data: (await import("./builders-X4JJZ6M2.js")).buildChannel(result.data) };
   }
   async editCurrent(payload) {
     const result = await this.rest.patch("/users/@me", toSnakeCase(payload));
@@ -2108,7 +2933,7 @@ var RoleManager = class {
     }
     const target = roles.find((r) => r.id === roleId);
     if (target) return { ok: true, data: target };
-    return { ok: false, status: 404, message: "Role not found" };
+    return { ok: false, status: 404, error: "Role not found", message: "Role not found" };
   }
   async list() {
     const result = await this.rest.get(`/guilds/${this.guildId}/roles`);
@@ -2467,7 +3292,7 @@ var ChannelManager = class extends BaseManager {
   }
   async clone(channelId, options, reason) {
     const cached = this.store.channels.get(channelId);
-    if (!cached) return { ok: false, status: 404, message: "Channel not found in cache" };
+    if (!cached) return { ok: false, status: 404, error: "Channel not found in cache", message: "Channel not found in cache" };
     const payload = { ...options };
     if (cached.name !== void 0) payload.name = cached.name;
     if (cached.type !== void 0) payload.type = cached.type;
@@ -2479,7 +3304,7 @@ var ChannelManager = class extends BaseManager {
     if (cached.position !== void 0) payload.position = cached.position;
     if (cached.parentId !== void 0) payload.parentId = cached.parentId;
     if (cached.permissionOverwrites !== void 0) payload.permissionOverwrites = cached.permissionOverwrites;
-    if (!cached.guildId) return { ok: false, status: 400, message: "Cannot clone a DM channel" };
+    if (!cached.guildId) return { ok: false, status: 400, error: "Cannot clone a DM channel", message: "Cannot clone a DM channel" };
     return this.create(cached.guildId, payload, reason);
   }
   async setPositions(guildId, positions, reason) {
@@ -3331,7 +4156,7 @@ var ApplicationManager = class {
   }
   async fetchRoleConnectionMetadata() {
     if (!this._client.user?.id) {
-      return { ok: false, status: 400, message: "Client not ready" };
+      return { ok: false, status: 400, error: "Client not ready", message: "Client not ready" };
     }
     const result = await this.rest.get(`/applications/${this._client.user.id}/role-connections/metadata`);
     if (!result.ok) return result;
@@ -3339,7 +4164,7 @@ var ApplicationManager = class {
   }
   async editRoleConnectionMetadata(records) {
     if (!this._client.user?.id) {
-      return { ok: false, status: 400, message: "Client not ready" };
+      return { ok: false, status: 400, error: "Client not ready", message: "Client not ready" };
     }
     const result = await this.rest.put(`/applications/${this._client.user.id}/role-connections/metadata`, records);
     if (!result.ok) return result;
@@ -4042,8 +4867,10 @@ var Client = class {
       case "INTERACTION_CREATE": {
         if (d.type === 2 /* APPLICATION_COMMAND */ || d.type === 4 /* APPLICATION_COMMAND_AUTOCOMPLETE */) {
           this.commands.handleInteraction(d).catch(console.error);
-        } else if (d.type === 3 /* MESSAGE_COMPONENT */ || d.type === 5 /* MODAL_SUBMIT */) {
+        } else if (d.type === 3 /* MESSAGE_COMPONENT */) {
           this.components.handleInteraction(d).catch(console.error);
+        } else if (d.type === 5 /* MODAL_SUBMIT */) {
+          this.commands.handleInteraction(d).catch(console.error);
         }
         this.dispatch("INTERACTION_CREATE", {
           type: "INTERACTION_CREATE",
@@ -4428,180 +5255,6 @@ var Chameleon = class {
   }
 };
 
-// src/utils/bitfield.ts
-var BitField = class _BitField {
-  static FLAGS = {};
-  bitfield;
-  constructor(bits = 0n) {
-    this.bitfield = this.constructor.resolve(bits);
-  }
-  has(bit) {
-    const resolved = this.constructor.resolve(bit);
-    return (this.bitfield & resolved) === resolved;
-  }
-  any(bit) {
-    const resolved = this.constructor.resolve(bit);
-    return (this.bitfield & resolved) !== 0n;
-  }
-  add(...bits) {
-    let total = 0n;
-    for (const bit of bits) {
-      total |= this.constructor.resolve(bit);
-    }
-    this.bitfield |= total;
-    return this;
-  }
-  remove(...bits) {
-    let total = 0n;
-    for (const bit of bits) {
-      total |= this.constructor.resolve(bit);
-    }
-    this.bitfield &= ~total;
-    return this;
-  }
-  toArray() {
-    const flags = this.constructor.FLAGS;
-    return Object.keys(flags).filter((flag) => this.has(flags[flag]));
-  }
-  serialize() {
-    const flags = this.constructor.FLAGS;
-    const result = {};
-    for (const [flag, value] of Object.entries(flags)) {
-      result[flag] = this.has(value);
-    }
-    return result;
-  }
-  equals(other) {
-    return this.bitfield === this.constructor.resolve(other);
-  }
-  freeze() {
-    return Object.freeze(this);
-  }
-  toString() {
-    return this.bitfield.toString();
-  }
-  toJSON() {
-    return this.toString();
-  }
-  static resolve(bit) {
-    if (typeof bit === "bigint") return bit;
-    if (typeof bit === "number") return BigInt(bit);
-    if (bit instanceof _BitField) return bit.bitfield;
-    if (typeof bit === "string") {
-      const flag = this.FLAGS[bit];
-      if (flag !== void 0) return flag;
-      const parsed = BigInt(bit);
-      return parsed;
-    }
-    if (Array.isArray(bit)) {
-      return bit.reduce((acc, b) => acc | this.resolve(b), 0n);
-    }
-    throw new TypeError(`Cannot resolve BitField from: ${bit}`);
-  }
-};
-
-// src/types/permissions.ts
-var PermissionsBitField = class _PermissionsBitField extends BitField {
-  static FLAGS = { ...DISCORD_PERMISSIONS };
-  static ALL = Object.values(DISCORD_PERMISSIONS).reduce((a, b) => a | b, 0n);
-  get isAdmin() {
-    return this.has("ADMINISTRATOR");
-  }
-  static from(bits) {
-    return new _PermissionsBitField(bits);
-  }
-};
-var UserFlagsBitField = class extends BitField {
-  static FLAGS = {
-    STAFF: 1n << 0n,
-    PARTNER: 1n << 1n,
-    HYPESQUAD: 1n << 2n,
-    BUG_HUNTER_LEVEL_1: 1n << 3n,
-    HYPESQUAD_ONLINE_HOUSE_1: 1n << 6n,
-    HYPESQUAD_ONLINE_HOUSE_2: 1n << 7n,
-    HYPESQUAD_ONLINE_HOUSE_3: 1n << 8n,
-    PREMIUM_EARLY_SUPPORTER: 1n << 9n,
-    TEAM_PSEUDO_USER: 1n << 10n,
-    BUG_HUNTER_LEVEL_2: 1n << 14n,
-    VERIFIED_BOT: 1n << 16n,
-    VERIFIED_DEVELOPER: 1n << 17n,
-    CERTIFIED_MODERATOR: 1n << 18n,
-    BOT_HTTP_INTERACTIONS: 1n << 19n,
-    ACTIVE_DEVELOPER: 1n << 22n
-  };
-};
-var IntentsBitField = class extends BitField {
-  static FLAGS = {
-    Guilds: 1n << 0n,
-    GuildMembers: 1n << 1n,
-    GuildModeration: 1n << 2n,
-    GuildEmojisAndStickers: 1n << 3n,
-    GuildIntegrations: 1n << 4n,
-    GuildWebhooks: 1n << 5n,
-    GuildInvites: 1n << 6n,
-    GuildVoiceStates: 1n << 7n,
-    GuildPresences: 1n << 8n,
-    GuildMessages: 1n << 9n,
-    GuildMessageReactions: 1n << 10n,
-    GuildMessageTyping: 1n << 11n,
-    DirectMessages: 1n << 12n,
-    DirectMessageReactions: 1n << 13n,
-    DirectMessageTyping: 1n << 14n,
-    MessageContent: 1n << 15n,
-    GuildScheduledEvents: 1n << 16n,
-    AutoModerationConfiguration: 1n << 20n,
-    AutoModerationExecution: 1n << 21n,
-    GuildMessagePolls: 1n << 24n,
-    DirectMessagePolls: 1n << 25n
-  };
-};
-function computeBasePermissions(member, guild) {
-  if (member.roles === void 0) return 0n;
-  const userId = member.user?.id;
-  if (userId && userId === guild.ownerId) return PermissionsBitField.ALL;
-  const everyoneRole = guild.roles.find((r) => r.id === guild.id);
-  let permissions = everyoneRole ? BigInt(everyoneRole.permissions) : 0n;
-  for (const roleId of member.roles) {
-    const role = guild.roles.find((r) => r.id === roleId);
-    if (role) permissions |= BigInt(role.permissions);
-  }
-  if ((permissions & DISCORD_PERMISSIONS.ADMINISTRATOR) === DISCORD_PERMISSIONS.ADMINISTRATOR) {
-    return PermissionsBitField.ALL;
-  }
-  return permissions;
-}
-function computeChannelPermissions(basePermissions, overwrites, memberRoles, memberId) {
-  if ((basePermissions & DISCORD_PERMISSIONS.ADMINISTRATOR) === DISCORD_PERMISSIONS.ADMINISTRATOR) {
-    return PermissionsBitField.ALL;
-  }
-  let permissions = basePermissions;
-  let allow = 0n;
-  let deny = 0n;
-  for (const overwrite of overwrites) {
-    if (overwrite.type === 0) {
-      if (memberRoles.includes(overwrite.id) || overwrites.indexOf(overwrite) === 0) {
-        if (overwrites.indexOf(overwrite) === 0 && !memberRoles.includes(overwrite.id)) {
-          permissions &= ~BigInt(overwrite.deny);
-          permissions |= BigInt(overwrite.allow);
-        } else {
-          allow |= BigInt(overwrite.allow);
-          deny |= BigInt(overwrite.deny);
-        }
-      }
-    }
-  }
-  permissions &= ~deny;
-  permissions |= allow;
-  if (memberId) {
-    const memberOverwrite = overwrites.find((ow) => ow.type === 1 && ow.id === memberId);
-    if (memberOverwrite) {
-      permissions &= ~BigInt(memberOverwrite.deny);
-      permissions |= BigInt(memberOverwrite.allow);
-    }
-  }
-  return permissions;
-}
-
 // src/sharding/manager.ts
 import { EventEmitter } from "events";
 import { fork } from "child_process";
@@ -4745,6 +5398,7 @@ export {
   BaseInteractionContext,
   BaseManager,
   BitField,
+  Button,
   ButtonBuilder,
   ButtonStyle,
   CHAMELEON_SELF_MAP,
@@ -4760,10 +5414,12 @@ export {
   CollectorManager,
   Colors,
   CommandContext,
+  CommandDefinitionBuilder,
   CommandManager,
   ComponentContext,
   ComponentManager,
   ComponentType,
+  Container,
   DISCORD_GATEWAY_OPCODES,
   DISCORD_PERMISSIONS,
   DefaultMessageNotificationLevel,
@@ -4787,6 +5443,7 @@ export {
   InviteManager,
   InviteTargetType,
   InviteType,
+  Label,
   LobbyMemberFlag,
   MFALevel,
   MemberManager,
@@ -4796,12 +5453,16 @@ export {
   MessageReferenceType,
   MessageType,
   ModalBuilder,
+  ModalContext,
+  ModalDefinitionBuilder,
   PermissionsBitField,
   PremiumTier,
   PremiumType,
   RoleManager,
   ScheduledEventManager,
+  Section,
   SelectMenuBuilder,
+  Separator,
   Shard,
   SkuFlag,
   SkuType,
@@ -4811,10 +5472,14 @@ export {
   StagePrivacyLevel,
   StickerFormatType,
   StickerType,
+  SubcommandDefinitionBuilder,
+  SubcommandGroupDefinitionBuilder,
   SubscriptionStatus,
   SystemChannelFlag,
   TemplateManager,
+  TextDisplay,
   TextInputBuilder,
+  Thumbnail,
   Tongue,
   TongueStore,
   UserFlag,
@@ -4843,7 +5508,10 @@ export {
   buildUser,
   buildVoiceState,
   buildWebhook,
+  choice,
+  choices,
   combinePermissions,
+  command,
   computeBasePermissions,
   computeChannelPermissions,
   defineButton,
@@ -4854,17 +5522,21 @@ export {
   defineRoleSelect,
   defineStringSelect,
   defineSubcommand,
+  defineSubcommandGroup,
   defineUserSelect,
   field,
   hasAllPermissions,
   hasAnyPermission,
   hasPermission,
   listPermissions,
+  modal,
   opt,
   resolveButtonStyle,
   resolveChannel,
   resolveGuild,
   resolveRole,
   resolveUser,
-  serializeComponent
+  serializeComponent,
+  subcommand,
+  subcommandGroup
 };