@jubbio/core 1.3.1 → 1.3.3

package/dist/esm/builders/SelectMenuBuilder.js

@@ -0,0 +1,161 @@
+/**
+ * SelectMenuBuilder for creating select menus
+ */
+/**
+ * A builder for creating string select menus
+ */
+export class StringSelectMenuBuilder {
+    data;
+    constructor(data = {}) {
+        this.data = { type: 3, ...data };
+        if (!this.data.options)
+            this.data.options = [];
+    }
+    /**
+     * Sets the custom ID of this select menu
+     * @param customId The custom ID
+     */
+    setCustomId(customId) {
+        this.data.custom_id = customId;
+        return this;
+    }
+    /**
+     * Sets the placeholder of this select menu
+     * @param placeholder The placeholder
+     */
+    setPlaceholder(placeholder) {
+        this.data.placeholder = placeholder;
+        return this;
+    }
+    /**
+     * Sets the minimum values of this select menu
+     * @param minValues The minimum values
+     */
+    setMinValues(minValues) {
+        this.data.min_values = minValues;
+        return this;
+    }
+    /**
+     * Sets the maximum values of this select menu
+     * @param maxValues The maximum values
+     */
+    setMaxValues(maxValues) {
+        this.data.max_values = maxValues;
+        return this;
+    }
+    /**
+     * Sets whether this select menu is disabled
+     * @param disabled Whether the select menu is disabled
+     */
+    setDisabled(disabled = true) {
+        this.data.disabled = disabled;
+        return this;
+    }
+    /**
+     * Adds options to this select menu
+     * @param options The options to add
+     */
+    addOptions(...options) {
+        if (!this.data.options)
+            this.data.options = [];
+        this.data.options.push(...options);
+        return this;
+    }
+    /**
+     * Sets the options of this select menu
+     * @param options The options to set
+     */
+    setOptions(...options) {
+        this.data.options = options;
+        return this;
+    }
+    /**
+     * Removes, replaces, or inserts options
+     * @param index The index to start at
+     * @param deleteCount The number of options to remove
+     * @param options The options to insert
+     */
+    spliceOptions(index, deleteCount, ...options) {
+        if (!this.data.options)
+            this.data.options = [];
+        this.data.options.splice(index, deleteCount, ...options);
+        return this;
+    }
+    /**
+     * Returns the JSON representation of this select menu
+     */
+    toJSON() {
+        return { ...this.data };
+    }
+    /**
+     * Creates a new select menu builder from existing data
+     * @param other The select menu data to copy
+     */
+    static from(other) {
+        return new StringSelectMenuBuilder(other instanceof StringSelectMenuBuilder ? other.data : other);
+    }
+}
+/**
+ * A builder for creating select menu options
+ */
+export class StringSelectMenuOptionBuilder {
+    data;
+    constructor(data = {}) {
+        this.data = { ...data };
+    }
+    /**
+     * Sets the label of this option
+     * @param label The label
+     */
+    setLabel(label) {
+        this.data.label = label;
+        return this;
+    }
+    /**
+     * Sets the value of this option
+     * @param value The value
+     */
+    setValue(value) {
+        this.data.value = value;
+        return this;
+    }
+    /**
+     * Sets the description of this option
+     * @param description The description
+     */
+    setDescription(description) {
+        this.data.description = description;
+        return this;
+    }
+    /**
+     * Sets the emoji of this option
+     * @param emoji The emoji
+     */
+    setEmoji(emoji) {
+        if (typeof emoji === 'string') {
+            this.data.emoji = { name: emoji };
+        }
+        else {
+            this.data.emoji = emoji;
+        }
+        return this;
+    }
+    /**
+     * Sets whether this option is the default
+     * @param isDefault Whether this option is the default
+     */
+    setDefault(isDefault = true) {
+        this.data.default = isDefault;
+        return this;
+    }
+    /**
+     * Returns the JSON representation of this option
+     */
+    toJSON() {
+        return { ...this.data };
+    }
+}
+// Alias for DJS compatibility
+export { StringSelectMenuBuilder as SelectMenuBuilder };
+export default StringSelectMenuBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SelectMenuBuilder.js","sourceRoot":"","sources":["../../../src/builders/SelectMenuBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SelectMenuBuilder for creating select menus\n */\n\nexport interface APISelectMenuOption {\n  label: string;\n  value: string;\n  description?: string;\n  emoji?: { id?: string; name?: string; animated?: boolean };\n  default?: boolean;\n}\n\nexport interface APISelectMenuComponent {\n  type: 3;\n  custom_id: string;\n  options?: APISelectMenuOption[];\n  placeholder?: string;\n  min_values?: number;\n  max_values?: number;\n  disabled?: boolean;\n}\n\n/**\n * A builder for creating string select menus\n */\nexport class StringSelectMenuBuilder {\n  public readonly data: Partial<APISelectMenuComponent>;\n\n  constructor(data: Partial<APISelectMenuComponent> = {}) {\n    this.data = { type: 3, ...data };\n    if (!this.data.options) this.data.options = [];\n  }\n\n  /**\n   * Sets the custom ID of this select menu\n   * @param customId The custom ID\n   */\n  setCustomId(customId: string): this {\n    this.data.custom_id = customId;\n    return this;\n  }\n\n  /**\n   * Sets the placeholder of this select menu\n   * @param placeholder The placeholder\n   */\n  setPlaceholder(placeholder: string): this {\n    this.data.placeholder = placeholder;\n    return this;\n  }\n\n  /**\n   * Sets the minimum values of this select menu\n   * @param minValues The minimum values\n   */\n  setMinValues(minValues: number): this {\n    this.data.min_values = minValues;\n    return this;\n  }\n\n  /**\n   * Sets the maximum values of this select menu\n   * @param maxValues The maximum values\n   */\n  setMaxValues(maxValues: number): this {\n    this.data.max_values = maxValues;\n    return this;\n  }\n\n  /**\n   * Sets whether this select menu is disabled\n   * @param disabled Whether the select menu is disabled\n   */\n  setDisabled(disabled = true): this {\n    this.data.disabled = disabled;\n    return this;\n  }\n\n  /**\n   * Adds options to this select menu\n   * @param options The options to add\n   */\n  addOptions(...options: APISelectMenuOption[]): this {\n    if (!this.data.options) this.data.options = [];\n    this.data.options.push(...options);\n    return this;\n  }\n\n  /**\n   * Sets the options of this select menu\n   * @param options The options to set\n   */\n  setOptions(...options: APISelectMenuOption[]): this {\n    this.data.options = options;\n    return this;\n  }\n\n  /**\n   * Removes, replaces, or inserts options\n   * @param index The index to start at\n   * @param deleteCount The number of options to remove\n   * @param options The options to insert\n   */\n  spliceOptions(index: number, deleteCount: number, ...options: APISelectMenuOption[]): this {\n    if (!this.data.options) this.data.options = [];\n    this.data.options.splice(index, deleteCount, ...options);\n    return this;\n  }\n\n  /**\n   * Returns the JSON representation of this select menu\n   */\n  toJSON(): APISelectMenuComponent {\n    return { ...this.data } as APISelectMenuComponent;\n  }\n\n  /**\n   * Creates a new select menu builder from existing data\n   * @param other The select menu data to copy\n   */\n  static from(other: Partial<APISelectMenuComponent> | StringSelectMenuBuilder): StringSelectMenuBuilder {\n    return new StringSelectMenuBuilder(other instanceof StringSelectMenuBuilder ? other.data : other);\n  }\n}\n\n/**\n * A builder for creating select menu options\n */\nexport class StringSelectMenuOptionBuilder {\n  public readonly data: Partial<APISelectMenuOption>;\n\n  constructor(data: Partial<APISelectMenuOption> = {}) {\n    this.data = { ...data };\n  }\n\n  /**\n   * Sets the label of this option\n   * @param label The label\n   */\n  setLabel(label: string): this {\n    this.data.label = label;\n    return this;\n  }\n\n  /**\n   * Sets the value of this option\n   * @param value The value\n   */\n  setValue(value: string): this {\n    this.data.value = value;\n    return this;\n  }\n\n  /**\n   * Sets the description of this option\n   * @param description The description\n   */\n  setDescription(description: string): this {\n    this.data.description = description;\n    return this;\n  }\n\n  /**\n   * Sets the emoji of this option\n   * @param emoji The emoji\n   */\n  setEmoji(emoji: { id?: string; name?: string; animated?: boolean } | string): this {\n    if (typeof emoji === 'string') {\n      this.data.emoji = { name: emoji };\n    } else {\n      this.data.emoji = emoji;\n    }\n    return this;\n  }\n\n  /**\n   * Sets whether this option is the default\n   * @param isDefault Whether this option is the default\n   */\n  setDefault(isDefault = true): this {\n    this.data.default = isDefault;\n    return this;\n  }\n\n  /**\n   * Returns the JSON representation of this option\n   */\n  toJSON(): APISelectMenuOption {\n    return { ...this.data } as APISelectMenuOption;\n  }\n}\n\n// Alias for DJS compatibility\nexport { StringSelectMenuBuilder as SelectMenuBuilder };\n\nexport default StringSelectMenuBuilder;\n"]}

package/dist/esm/builders/SlashCommandBuilder.js

@@ -0,0 +1,311 @@
+/**
+ * SlashCommandBuilder for creating slash commands
+ */
+/**
+ * Application command option types
+ */
+export var ApplicationCommandOptionType;
+(function (ApplicationCommandOptionType) {
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Subcommand"] = 1] = "Subcommand";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["SubcommandGroup"] = 2] = "SubcommandGroup";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["String"] = 3] = "String";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Integer"] = 4] = "Integer";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Boolean"] = 5] = "Boolean";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["User"] = 6] = "User";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Channel"] = 7] = "Channel";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Role"] = 8] = "Role";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Mentionable"] = 9] = "Mentionable";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Number"] = 10] = "Number";
+    ApplicationCommandOptionType[ApplicationCommandOptionType["Attachment"] = 11] = "Attachment";
+})(ApplicationCommandOptionType || (ApplicationCommandOptionType = {}));
+/**
+ * A builder for creating slash command options
+ */
+class SlashCommandOptionBuilder {
+    data;
+    constructor(type) {
+        this.data = { type };
+    }
+    setName(name) {
+        this.data.name = name;
+        return this;
+    }
+    setDescription(description) {
+        this.data.description = description;
+        return this;
+    }
+    setRequired(required = true) {
+        this.data.required = required;
+        return this;
+    }
+    toJSON() {
+        return { ...this.data };
+    }
+}
+/**
+ * String option builder
+ */
+export class SlashCommandStringOption extends SlashCommandOptionBuilder {
+    constructor() {
+        super(ApplicationCommandOptionType.String);
+    }
+    addChoices(...choices) {
+        if (!this.data.choices)
+            this.data.choices = [];
+        this.data.choices.push(...choices);
+        return this;
+    }
+    setChoices(...choices) {
+        this.data.choices = choices;
+        return this;
+    }
+    setMinLength(minLength) {
+        this.data.min_length = minLength;
+        return this;
+    }
+    setMaxLength(maxLength) {
+        this.data.max_length = maxLength;
+        return this;
+    }
+    setAutocomplete(autocomplete = true) {
+        this.data.autocomplete = autocomplete;
+        return this;
+    }
+}
+/**
+ * Integer option builder
+ */
+export class SlashCommandIntegerOption extends SlashCommandOptionBuilder {
+    constructor() {
+        super(ApplicationCommandOptionType.Integer);
+    }
+    addChoices(...choices) {
+        if (!this.data.choices)
+            this.data.choices = [];
+        this.data.choices.push(...choices);
+        return this;
+    }
+    setMinValue(minValue) {
+        this.data.min_value = minValue;
+        return this;
+    }
+    setMaxValue(maxValue) {
+        this.data.max_value = maxValue;
+        return this;
+    }
+    setAutocomplete(autocomplete = true) {
+        this.data.autocomplete = autocomplete;
+        return this;
+    }
+}
+/**
+ * Number option builder
+ */
+export class SlashCommandNumberOption extends SlashCommandOptionBuilder {
+    constructor() {
+        super(ApplicationCommandOptionType.Number);
+    }
+    addChoices(...choices) {
+        if (!this.data.choices)
+            this.data.choices = [];
+        this.data.choices.push(...choices);
+        return this;
+    }
+    setMinValue(minValue) {
+        this.data.min_value = minValue;
+        return this;
+    }
+    setMaxValue(maxValue) {
+        this.data.max_value = maxValue;
+        return this;
+    }
+    setAutocomplete(autocomplete = true) {
+        this.data.autocomplete = autocomplete;
+        return this;
+    }
+}
+/**
+ * Boolean option builder
+ */
+export class SlashCommandBooleanOption extends SlashCommandOptionBuilder {
+    constructor() {
+        super(ApplicationCommandOptionType.Boolean);
+    }
+}
+/**
+ * User option builder
+ */
+export class SlashCommandUserOption extends SlashCommandOptionBuilder {
+    constructor() {
+        super(ApplicationCommandOptionType.User);
+    }
+}
+/**
+ * Channel option builder
+ */
+export class SlashCommandChannelOption extends SlashCommandOptionBuilder {
+    constructor() {
+        super(ApplicationCommandOptionType.Channel);
+    }
+    addChannelTypes(...types) {
+        if (!this.data.channel_types)
+            this.data.channel_types = [];
+        this.data.channel_types.push(...types);
+        return this;
+    }
+}
+/**
+ * Role option builder
+ */
+export class SlashCommandRoleOption extends SlashCommandOptionBuilder {
+    constructor() {
+        super(ApplicationCommandOptionType.Role);
+    }
+}
+/**
+ * Mentionable option builder
+ */
+export class SlashCommandMentionableOption extends SlashCommandOptionBuilder {
+    constructor() {
+        super(ApplicationCommandOptionType.Mentionable);
+    }
+}
+/**
+ * Attachment option builder
+ */
+export class SlashCommandAttachmentOption extends SlashCommandOptionBuilder {
+    constructor() {
+        super(ApplicationCommandOptionType.Attachment);
+    }
+}
+/**
+ * A builder for creating slash commands
+ */
+export class SlashCommandBuilder {
+    data;
+    constructor() {
+        this.data = { options: [] };
+    }
+    /**
+     * Sets the name of this command
+     * @param name The name
+     */
+    setName(name) {
+        this.data.name = name;
+        return this;
+    }
+    /**
+     * Sets the description of this command
+     * @param description The description
+     */
+    setDescription(description) {
+        this.data.description = description;
+        return this;
+    }
+    /**
+     * Sets the default member permissions required to use this command
+     * @param permissions The permissions
+     */
+    setDefaultMemberPermissions(permissions) {
+        this.data.default_member_permissions = permissions === null
+            ? undefined
+            : String(permissions);
+        return this;
+    }
+    /**
+     * Sets whether this command is available in DMs
+     * @param enabled Whether the command is available in DMs
+     */
+    setDMPermission(enabled) {
+        this.data.dm_permission = enabled;
+        return this;
+    }
+    /**
+     * Sets whether this command is NSFW
+     * @param nsfw Whether the command is NSFW
+     */
+    setNSFW(nsfw = true) {
+        this.data.nsfw = nsfw;
+        return this;
+    }
+    /**
+     * Adds a string option
+     */
+    addStringOption(fn) {
+        const option = fn(new SlashCommandStringOption());
+        this.data.options.push(option.toJSON());
+        return this;
+    }
+    /**
+     * Adds an integer option
+     */
+    addIntegerOption(fn) {
+        const option = fn(new SlashCommandIntegerOption());
+        this.data.options.push(option.toJSON());
+        return this;
+    }
+    /**
+     * Adds a number option
+     */
+    addNumberOption(fn) {
+        const option = fn(new SlashCommandNumberOption());
+        this.data.options.push(option.toJSON());
+        return this;
+    }
+    /**
+     * Adds a boolean option
+     */
+    addBooleanOption(fn) {
+        const option = fn(new SlashCommandBooleanOption());
+        this.data.options.push(option.toJSON());
+        return this;
+    }
+    /**
+     * Adds a user option
+     */
+    addUserOption(fn) {
+        const option = fn(new SlashCommandUserOption());
+        this.data.options.push(option.toJSON());
+        return this;
+    }
+    /**
+     * Adds a channel option
+     */
+    addChannelOption(fn) {
+        const option = fn(new SlashCommandChannelOption());
+        this.data.options.push(option.toJSON());
+        return this;
+    }
+    /**
+     * Adds a role option
+     */
+    addRoleOption(fn) {
+        const option = fn(new SlashCommandRoleOption());
+        this.data.options.push(option.toJSON());
+        return this;
+    }
+    /**
+     * Adds a mentionable option
+     */
+    addMentionableOption(fn) {
+        const option = fn(new SlashCommandMentionableOption());
+        this.data.options.push(option.toJSON());
+        return this;
+    }
+    /**
+     * Adds an attachment option
+     */
+    addAttachmentOption(fn) {
+        const option = fn(new SlashCommandAttachmentOption());
+        this.data.options.push(option.toJSON());
+        return this;
+    }
+    /**
+     * Returns the JSON representation of this command
+     */
+    toJSON() {
+        return { ...this.data };
+    }
+}
+export default SlashCommandBuilder;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"SlashCommandBuilder.js","sourceRoot":"","sources":["../../../src/builders/SlashCommandBuilder.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * SlashCommandBuilder for creating slash commands\n */\n\n/**\n * Application command option types\n */\nexport enum ApplicationCommandOptionType {\n  Subcommand = 1,\n  SubcommandGroup = 2,\n  String = 3,\n  Integer = 4,\n  Boolean = 5,\n  User = 6,\n  Channel = 7,\n  Role = 8,\n  Mentionable = 9,\n  Number = 10,\n  Attachment = 11,\n}\n\nexport interface APIApplicationCommandOptionChoice {\n  name: string;\n  value: string | number;\n}\n\nexport interface APIApplicationCommandOption {\n  type: ApplicationCommandOptionType;\n  name: string;\n  description: string;\n  required?: boolean;\n  choices?: APIApplicationCommandOptionChoice[];\n  options?: APIApplicationCommandOption[];\n  min_value?: number;\n  max_value?: number;\n  min_length?: number;\n  max_length?: number;\n  autocomplete?: boolean;\n  channel_types?: number[];\n}\n\nexport interface APIApplicationCommand {\n  name: string;\n  description: string;\n  options?: APIApplicationCommandOption[];\n  default_member_permissions?: string;\n  dm_permission?: boolean;\n  nsfw?: boolean;\n}\n\n/**\n * A builder for creating slash command options\n */\nclass SlashCommandOptionBuilder {\n  protected data: Partial<APIApplicationCommandOption>;\n\n  constructor(type: ApplicationCommandOptionType) {\n    this.data = { type };\n  }\n\n  setName(name: string): this {\n    this.data.name = name;\n    return this;\n  }\n\n  setDescription(description: string): this {\n    this.data.description = description;\n    return this;\n  }\n\n  setRequired(required = true): this {\n    this.data.required = required;\n    return this;\n  }\n\n  toJSON(): APIApplicationCommandOption {\n    return { ...this.data } as APIApplicationCommandOption;\n  }\n}\n\n/**\n * String option builder\n */\nexport class SlashCommandStringOption extends SlashCommandOptionBuilder {\n  constructor() {\n    super(ApplicationCommandOptionType.String);\n  }\n\n  addChoices(...choices: APIApplicationCommandOptionChoice[]): this {\n    if (!this.data.choices) this.data.choices = [];\n    this.data.choices.push(...choices);\n    return this;\n  }\n\n  setChoices(...choices: APIApplicationCommandOptionChoice[]): this {\n    this.data.choices = choices;\n    return this;\n  }\n\n  setMinLength(minLength: number): this {\n    this.data.min_length = minLength;\n    return this;\n  }\n\n  setMaxLength(maxLength: number): this {\n    this.data.max_length = maxLength;\n    return this;\n  }\n\n  setAutocomplete(autocomplete = true): this {\n    this.data.autocomplete = autocomplete;\n    return this;\n  }\n}\n\n/**\n * Integer option builder\n */\nexport class SlashCommandIntegerOption extends SlashCommandOptionBuilder {\n  constructor() {\n    super(ApplicationCommandOptionType.Integer);\n  }\n\n  addChoices(...choices: APIApplicationCommandOptionChoice[]): this {\n    if (!this.data.choices) this.data.choices = [];\n    this.data.choices.push(...choices);\n    return this;\n  }\n\n  setMinValue(minValue: number): this {\n    this.data.min_value = minValue;\n    return this;\n  }\n\n  setMaxValue(maxValue: number): this {\n    this.data.max_value = maxValue;\n    return this;\n  }\n\n  setAutocomplete(autocomplete = true): this {\n    this.data.autocomplete = autocomplete;\n    return this;\n  }\n}\n\n/**\n * Number option builder\n */\nexport class SlashCommandNumberOption extends SlashCommandOptionBuilder {\n  constructor() {\n    super(ApplicationCommandOptionType.Number);\n  }\n\n  addChoices(...choices: APIApplicationCommandOptionChoice[]): this {\n    if (!this.data.choices) this.data.choices = [];\n    this.data.choices.push(...choices);\n    return this;\n  }\n\n  setMinValue(minValue: number): this {\n    this.data.min_value = minValue;\n    return this;\n  }\n\n  setMaxValue(maxValue: number): this {\n    this.data.max_value = maxValue;\n    return this;\n  }\n\n  setAutocomplete(autocomplete = true): this {\n    this.data.autocomplete = autocomplete;\n    return this;\n  }\n}\n\n/**\n * Boolean option builder\n */\nexport class SlashCommandBooleanOption extends SlashCommandOptionBuilder {\n  constructor() {\n    super(ApplicationCommandOptionType.Boolean);\n  }\n}\n\n/**\n * User option builder\n */\nexport class SlashCommandUserOption extends SlashCommandOptionBuilder {\n  constructor() {\n    super(ApplicationCommandOptionType.User);\n  }\n}\n\n/**\n * Channel option builder\n */\nexport class SlashCommandChannelOption extends SlashCommandOptionBuilder {\n  constructor() {\n    super(ApplicationCommandOptionType.Channel);\n  }\n\n  addChannelTypes(...types: number[]): this {\n    if (!this.data.channel_types) this.data.channel_types = [];\n    this.data.channel_types.push(...types);\n    return this;\n  }\n}\n\n/**\n * Role option builder\n */\nexport class SlashCommandRoleOption extends SlashCommandOptionBuilder {\n  constructor() {\n    super(ApplicationCommandOptionType.Role);\n  }\n}\n\n/**\n * Mentionable option builder\n */\nexport class SlashCommandMentionableOption extends SlashCommandOptionBuilder {\n  constructor() {\n    super(ApplicationCommandOptionType.Mentionable);\n  }\n}\n\n/**\n * Attachment option builder\n */\nexport class SlashCommandAttachmentOption extends SlashCommandOptionBuilder {\n  constructor() {\n    super(ApplicationCommandOptionType.Attachment);\n  }\n}\n\n/**\n * A builder for creating slash commands\n */\nexport class SlashCommandBuilder {\n  public readonly data: Partial<APIApplicationCommand>;\n\n  constructor() {\n    this.data = { options: [] };\n  }\n\n  /**\n   * Sets the name of this command\n   * @param name The name\n   */\n  setName(name: string): this {\n    this.data.name = name;\n    return this;\n  }\n\n  /**\n   * Sets the description of this command\n   * @param description The description\n   */\n  setDescription(description: string): this {\n    this.data.description = description;\n    return this;\n  }\n\n  /**\n   * Sets the default member permissions required to use this command\n   * @param permissions The permissions\n   */\n  setDefaultMemberPermissions(permissions: bigint | string | null): this {\n    this.data.default_member_permissions = permissions === null \n      ? undefined \n      : String(permissions);\n    return this;\n  }\n\n  /**\n   * Sets whether this command is available in DMs\n   * @param enabled Whether the command is available in DMs\n   */\n  setDMPermission(enabled: boolean): this {\n    this.data.dm_permission = enabled;\n    return this;\n  }\n\n  /**\n   * Sets whether this command is NSFW\n   * @param nsfw Whether the command is NSFW\n   */\n  setNSFW(nsfw = true): this {\n    this.data.nsfw = nsfw;\n    return this;\n  }\n\n  /**\n   * Adds a string option\n   */\n  addStringOption(fn: (option: SlashCommandStringOption) => SlashCommandStringOption): this {\n    const option = fn(new SlashCommandStringOption());\n    this.data.options!.push(option.toJSON());\n    return this;\n  }\n\n  /**\n   * Adds an integer option\n   */\n  addIntegerOption(fn: (option: SlashCommandIntegerOption) => SlashCommandIntegerOption): this {\n    const option = fn(new SlashCommandIntegerOption());\n    this.data.options!.push(option.toJSON());\n    return this;\n  }\n\n  /**\n   * Adds a number option\n   */\n  addNumberOption(fn: (option: SlashCommandNumberOption) => SlashCommandNumberOption): this {\n    const option = fn(new SlashCommandNumberOption());\n    this.data.options!.push(option.toJSON());\n    return this;\n  }\n\n  /**\n   * Adds a boolean option\n   */\n  addBooleanOption(fn: (option: SlashCommandBooleanOption) => SlashCommandBooleanOption): this {\n    const option = fn(new SlashCommandBooleanOption());\n    this.data.options!.push(option.toJSON());\n    return this;\n  }\n\n  /**\n   * Adds a user option\n   */\n  addUserOption(fn: (option: SlashCommandUserOption) => SlashCommandUserOption): this {\n    const option = fn(new SlashCommandUserOption());\n    this.data.options!.push(option.toJSON());\n    return this;\n  }\n\n  /**\n   * Adds a channel option\n   */\n  addChannelOption(fn: (option: SlashCommandChannelOption) => SlashCommandChannelOption): this {\n    const option = fn(new SlashCommandChannelOption());\n    this.data.options!.push(option.toJSON());\n    return this;\n  }\n\n  /**\n   * Adds a role option\n   */\n  addRoleOption(fn: (option: SlashCommandRoleOption) => SlashCommandRoleOption): this {\n    const option = fn(new SlashCommandRoleOption());\n    this.data.options!.push(option.toJSON());\n    return this;\n  }\n\n  /**\n   * Adds a mentionable option\n   */\n  addMentionableOption(fn: (option: SlashCommandMentionableOption) => SlashCommandMentionableOption): this {\n    const option = fn(new SlashCommandMentionableOption());\n    this.data.options!.push(option.toJSON());\n    return this;\n  }\n\n  /**\n   * Adds an attachment option\n   */\n  addAttachmentOption(fn: (option: SlashCommandAttachmentOption) => SlashCommandAttachmentOption): this {\n    const option = fn(new SlashCommandAttachmentOption());\n    this.data.options!.push(option.toJSON());\n    return this;\n  }\n\n  /**\n   * Returns the JSON representation of this command\n   */\n  toJSON(): APIApplicationCommand {\n    return { ...this.data } as APIApplicationCommand;\n  }\n}\n\nexport default SlashCommandBuilder;\n"]}

package/dist/esm/builders/index.js

@@ -0,0 +1,10 @@
+/**
+ * Builder exports
+ */
+export * from './EmbedBuilder';
+export * from './ButtonBuilder';
+export * from './SelectMenuBuilder';
+export * from './ActionRowBuilder';
+export * from './ModalBuilder';
+export * from './SlashCommandBuilder';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvYnVpbGRlcnMvaW5kZXgudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IkFBQUE7O0dBRUc7QUFFSCxjQUFjLGdCQUFnQixDQUFDO0FBQy9CLGNBQWMsaUJBQWlCLENBQUM7QUFDaEMsY0FBYyxxQkFBcUIsQ0FBQztBQUNwQyxjQUFjLG9CQUFvQixDQUFDO0FBQ25DLGNBQWMsZ0JBQWdCLENBQUM7QUFDL0IsY0FBYyx1QkFBdUIsQ0FBQyIsInNvdXJjZXNDb250ZW50IjpbIi8qKlxuICogQnVpbGRlciBleHBvcnRzXG4gKi9cblxuZXhwb3J0ICogZnJvbSAnLi9FbWJlZEJ1aWxkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9CdXR0b25CdWlsZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vU2VsZWN0TWVudUJ1aWxkZXInO1xuZXhwb3J0ICogZnJvbSAnLi9BY3Rpb25Sb3dCdWlsZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vTW9kYWxCdWlsZGVyJztcbmV4cG9ydCAqIGZyb20gJy4vU2xhc2hDb21tYW5kQnVpbGRlcic7XG4iXX0=