@minesa-org/mini-interaction 0.0.3 → 0.0.5

package/dist/builders/AutomodRuleBuilder.d.ts

@@ -0,0 +1,45 @@
+import { type APIAutoModerationAction, type APIAutoModerationRuleTriggerMetadata, AutoModerationRuleEventType, AutoModerationRuleTriggerType } from "discord-api-types/v10";
+import type { RESTPostAPIAutoModerationRuleJSONBody } from "discord-api-types/v10";
+import type { JSONEncodable } from "./shared.js";
+/**
+ * Shape describing initial data used to seed the auto moderation rule builder.
+ */
+export type AutomodRuleBuilderData = Partial<RESTPostAPIAutoModerationRuleJSONBody> & {
+    name?: string;
+    event_type?: AutoModerationRuleEventType;
+    trigger_type?: AutoModerationRuleTriggerType;
+    actions?: APIAutoModerationAction[];
+};
+/** Builder that produces Discord auto moderation rule payloads. */
+export declare class AutomodRuleBuilder implements JSONEncodable<RESTPostAPIAutoModerationRuleJSONBody> {
+    private data;
+    constructor(data?: AutomodRuleBuilderData);
+    /** Sets the name of the rule. */
+    setName(name: string): this;
+    /** Sets the event type that will trigger the rule. */
+    setEventType(eventType: AutoModerationRuleEventType): this;
+    /** Sets the trigger type for the rule. */
+    setTriggerType(triggerType: AutoModerationRuleTriggerType): this;
+    /**
+     * Assigns trigger metadata describing how the rule should match content.
+     */
+    setTriggerMetadata(metadata: APIAutoModerationRuleTriggerMetadata | null | undefined): this;
+    /**
+     * Replaces the actions executed when the rule triggers.
+     */
+    setActions(actions: Array<APIAutoModerationAction | JSONEncodable<APIAutoModerationAction>>): this;
+    /** Adds an action to execute when the rule triggers. */
+    addAction(action: APIAutoModerationAction | JSONEncodable<APIAutoModerationAction>): this;
+    /** Enables or disables the rule. */
+    setEnabled(enabled: boolean): this;
+    /** Replaces the list of exempt role ids. */
+    setExemptRoles(roleIds: string[]): this;
+    /** Adds an exempt role id if not already present. */
+    addExemptRole(roleId: string): this;
+    /** Replaces the list of exempt channel ids. */
+    setExemptChannels(channelIds: string[]): this;
+    /** Adds an exempt channel id if not already present. */
+    addExemptChannel(channelId: string): this;
+    /** Serialises the builder into a REST auto moderation rule payload. */
+    toJSON(): RESTPostAPIAutoModerationRuleJSONBody;
+}

package/dist/builders/AutomodRuleBuilder.js

@@ -0,0 +1,151 @@
+import { resolveJSONEncodable } from "./shared.js";
+/** Builder that produces Discord auto moderation rule payloads. */
+export class AutomodRuleBuilder {
+    data;
+    constructor(data = {}) {
+        this.data = {
+            ...data,
+            actions: data.actions?.map(cloneAutoModerationAction) ?? [],
+            trigger_metadata: data.trigger_metadata
+                ? cloneTriggerMetadata(data.trigger_metadata)
+                : undefined,
+            exempt_roles: data.exempt_roles ? [...data.exempt_roles] : undefined,
+            exempt_channels: data.exempt_channels
+                ? [...data.exempt_channels]
+                : undefined,
+        };
+    }
+    /** Sets the name of the rule. */
+    setName(name) {
+        this.data.name = name;
+        return this;
+    }
+    /** Sets the event type that will trigger the rule. */
+    setEventType(eventType) {
+        this.data.event_type = eventType;
+        return this;
+    }
+    /** Sets the trigger type for the rule. */
+    setTriggerType(triggerType) {
+        this.data.trigger_type = triggerType;
+        return this;
+    }
+    /**
+     * Assigns trigger metadata describing how the rule should match content.
+     */
+    setTriggerMetadata(metadata) {
+        this.data.trigger_metadata = metadata
+            ? cloneTriggerMetadata(metadata)
+            : undefined;
+        return this;
+    }
+    /**
+     * Replaces the actions executed when the rule triggers.
+     */
+    setActions(actions) {
+        this.data.actions = actions.map((action) => cloneAutoModerationAction(resolveJSONEncodable(action)));
+        return this;
+    }
+    /** Adds an action to execute when the rule triggers. */
+    addAction(action) {
+        if (!this.data.actions) {
+            this.data.actions = [];
+        }
+        this.data.actions.push(cloneAutoModerationAction(resolveJSONEncodable(action)));
+        return this;
+    }
+    /** Enables or disables the rule. */
+    setEnabled(enabled) {
+        this.data.enabled = enabled;
+        return this;
+    }
+    /** Replaces the list of exempt role ids. */
+    setExemptRoles(roleIds) {
+        this.data.exempt_roles = [...roleIds];
+        return this;
+    }
+    /** Adds an exempt role id if not already present. */
+    addExemptRole(roleId) {
+        if (!this.data.exempt_roles) {
+            this.data.exempt_roles = [];
+        }
+        if (!this.data.exempt_roles.includes(roleId)) {
+            this.data.exempt_roles.push(roleId);
+        }
+        return this;
+    }
+    /** Replaces the list of exempt channel ids. */
+    setExemptChannels(channelIds) {
+        this.data.exempt_channels = [...channelIds];
+        return this;
+    }
+    /** Adds an exempt channel id if not already present. */
+    addExemptChannel(channelId) {
+        if (!this.data.exempt_channels) {
+            this.data.exempt_channels = [];
+        }
+        if (!this.data.exempt_channels.includes(channelId)) {
+            this.data.exempt_channels.push(channelId);
+        }
+        return this;
+    }
+    /** Serialises the builder into a REST auto moderation rule payload. */
+    toJSON() {
+        const { name, event_type, trigger_type } = this.data;
+        const actions = this.data.actions ?? [];
+        if (!name) {
+            throw new Error("[AutomodRuleBuilder] name is required");
+        }
+        if (event_type === undefined) {
+            throw new Error("[AutomodRuleBuilder] event type is required");
+        }
+        if (trigger_type === undefined) {
+            throw new Error("[AutomodRuleBuilder] trigger type is required");
+        }
+        if (actions.length === 0) {
+            throw new Error("[AutomodRuleBuilder] at least one action is required");
+        }
+        return {
+            name,
+            event_type,
+            trigger_type,
+            trigger_metadata: this.data.trigger_metadata
+                ? cloneTriggerMetadata(this.data.trigger_metadata)
+                : undefined,
+            actions: actions.map(cloneAutoModerationAction),
+            enabled: this.data.enabled,
+            exempt_roles: this.data.exempt_roles
+                ? [...this.data.exempt_roles]
+                : undefined,
+            exempt_channels: this.data.exempt_channels
+                ? [...this.data.exempt_channels]
+                : undefined,
+        };
+    }
+}
+function cloneTriggerMetadata(metadata) {
+    return {
+        keyword_filter: metadata.keyword_filter
+            ? [...metadata.keyword_filter]
+            : undefined,
+        presets: metadata.presets ? [...metadata.presets] : undefined,
+        allow_list: metadata.allow_list ? [...metadata.allow_list] : undefined,
+        regex_patterns: metadata.regex_patterns
+            ? [...metadata.regex_patterns]
+            : undefined,
+        mention_total_limit: metadata.mention_total_limit,
+        mention_raid_protection_enabled: metadata.mention_raid_protection_enabled,
+    };
+}
+function cloneAutoModerationAction(action) {
+    return {
+        type: action.type,
+        metadata: action.metadata
+            ? {
+                channel_id: action.metadata.channel_id,
+                duration_seconds: action.metadata.duration_seconds,
+                custom_message: action.metadata.custom_message,
+            }
+            : undefined,
+    };
+}

package/dist/builders/EmbedBuilder.d.ts

@@ -0,0 +1,33 @@
+import { type APIEmbed, type APIEmbedAuthor, type APIEmbedField, type APIEmbedFooter, type APIEmbedImage, type APIEmbedThumbnail } from "discord-api-types/v10";
+import type { JSONEncodable } from "./shared.js";
+/** Shape describing data used to seed an embed builder instance. */
+export type EmbedBuilderData = Partial<APIEmbed>;
+/** Builder for Discord embed payloads. */
+export declare class EmbedBuilder implements JSONEncodable<APIEmbed> {
+    private data;
+    constructor(data?: EmbedBuilderData);
+    /** Sets or clears the embed title. */
+    setTitle(title: string | null | undefined): this;
+    /** Sets or clears the embed description. */
+    setDescription(description: string | null | undefined): this;
+    /** Sets or clears the embed URL. */
+    setURL(url: string | null | undefined): this;
+    /** Sets or clears the embed color. */
+    setColor(color: number | null | undefined): this;
+    /** Sets the timestamp value using either a Date or ISO string. */
+    setTimestamp(timestamp: Date | number | string | null | undefined): this;
+    /** Sets or clears the footer. */
+    setFooter(footer: APIEmbedFooter | null | undefined): this;
+    /** Sets or clears the image. */
+    setImage(image: APIEmbedImage | null | undefined): this;
+    /** Sets or clears the thumbnail. */
+    setThumbnail(thumbnail: APIEmbedThumbnail | null | undefined): this;
+    /** Sets or clears the author. */
+    setAuthor(author: APIEmbedAuthor | null | undefined): this;
+    /** Replaces the embed fields with the provided values. */
+    setFields(fields: APIEmbedField[]): this;
+    /** Appends fields to the embed. */
+    addFields(...fields: APIEmbedField[]): this;
+    /** Serialises the builder into an API compatible embed payload. */
+    toJSON(): APIEmbed;
+}

package/dist/builders/EmbedBuilder.js

@@ -0,0 +1,94 @@
+/** Builder for Discord embed payloads. */
+export class EmbedBuilder {
+    data;
+    constructor(data = {}) {
+        this.data = {
+            ...data,
+            footer: data.footer ? { ...data.footer } : undefined,
+            image: data.image ? { ...data.image } : undefined,
+            thumbnail: data.thumbnail ? { ...data.thumbnail } : undefined,
+            author: data.author ? { ...data.author } : undefined,
+            fields: data.fields ? data.fields.map((field) => ({ ...field })) : [],
+        };
+    }
+    /** Sets or clears the embed title. */
+    setTitle(title) {
+        this.data.title = title ?? undefined;
+        return this;
+    }
+    /** Sets or clears the embed description. */
+    setDescription(description) {
+        this.data.description = description ?? undefined;
+        return this;
+    }
+    /** Sets or clears the embed URL. */
+    setURL(url) {
+        this.data.url = url ?? undefined;
+        return this;
+    }
+    /** Sets or clears the embed color. */
+    setColor(color) {
+        this.data.color = color ?? undefined;
+        return this;
+    }
+    /** Sets the timestamp value using either a Date or ISO string. */
+    setTimestamp(timestamp) {
+        if (timestamp === null || timestamp === undefined) {
+            this.data.timestamp = undefined;
+        }
+        else if (timestamp instanceof Date) {
+            this.data.timestamp = timestamp.toISOString();
+        }
+        else if (typeof timestamp === "number") {
+            this.data.timestamp = new Date(timestamp).toISOString();
+        }
+        else {
+            this.data.timestamp = new Date(timestamp).toISOString();
+        }
+        return this;
+    }
+    /** Sets or clears the footer. */
+    setFooter(footer) {
+        this.data.footer = footer ? { ...footer } : undefined;
+        return this;
+    }
+    /** Sets or clears the image. */
+    setImage(image) {
+        this.data.image = image ? { ...image } : undefined;
+        return this;
+    }
+    /** Sets or clears the thumbnail. */
+    setThumbnail(thumbnail) {
+        this.data.thumbnail = thumbnail ? { ...thumbnail } : undefined;
+        return this;
+    }
+    /** Sets or clears the author. */
+    setAuthor(author) {
+        this.data.author = author ? { ...author } : undefined;
+        return this;
+    }
+    /** Replaces the embed fields with the provided values. */
+    setFields(fields) {
+        this.data.fields = fields.map((field) => ({ ...field }));
+        return this;
+    }
+    /** Appends fields to the embed. */
+    addFields(...fields) {
+        if (!this.data.fields) {
+            this.data.fields = [];
+        }
+        this.data.fields.push(...fields.map((field) => ({ ...field })));
+        return this;
+    }
+    /** Serialises the builder into an API compatible embed payload. */
+    toJSON() {
+        return {
+            ...this.data,
+            footer: this.data.footer ? { ...this.data.footer } : undefined,
+            image: this.data.image ? { ...this.data.image } : undefined,
+            thumbnail: this.data.thumbnail ? { ...this.data.thumbnail } : undefined,
+            author: this.data.author ? { ...this.data.author } : undefined,
+            fields: this.data.fields?.map((field) => ({ ...field })),
+        };
+    }
+}

package/dist/builders/MiniContainerBuilder.d.ts

@@ -0,0 +1,131 @@
+import type { APIComponentInContainer, APIContainerComponent, APIMediaGalleryComponent, APIMediaGalleryItem, APISectionAccessoryComponent, APISectionComponent, APISeparatorComponent, APITextDisplayComponent, APIThumbnailComponent, APIUnfurledMediaItem } from "discord-api-types/v10";
+import { SeparatorSpacingSize } from "discord-api-types/v10";
+import type { JSONEncodable } from "./shared.js";
+/** Structured message container payload. */
+export type MiniContainerComponent = APIContainerComponent;
+/** Section within a structured message container. */
+export type MiniSectionComponent = APISectionComponent;
+/** Text display structured message component. */
+export type MiniTextDisplayComponent = APITextDisplayComponent;
+/** Separator structured message component. */
+export type MiniSeparatorComponent = APISeparatorComponent;
+/** Thumbnail payload used within sections. */
+export type MiniThumbnailComponent = APIThumbnailComponent;
+/** Gallery item payload. */
+export type MiniGalleryItemComponent = APIMediaGalleryItem;
+/** Gallery structured message component. */
+export type MiniGalleryComponent = APIMediaGalleryComponent;
+/** Union of supported components within a container. */
+export type MiniContentComponent = APIComponentInContainer;
+/** Union of supported section accessory components. */
+export type MiniSectionAccessoryComponent = APISectionAccessoryComponent;
+/** Data accepted by the container builder constructor. */
+export type MiniContainerBuilderData = Partial<Omit<MiniContainerComponent, "components">> & {
+    components?: Array<MiniContentComponent | JSONEncodable<MiniContentComponent>>;
+};
+/** Data accepted by the section builder constructor. */
+export type MiniSectionBuilderData = Partial<Omit<MiniSectionComponent, "components" | "accessory">> & {
+    components?: Array<MiniTextDisplayComponent | JSONEncodable<MiniTextDisplayComponent>>;
+    accessory?: MiniSectionAccessoryComponent | JSONEncodable<MiniSectionAccessoryComponent>;
+};
+/** Data accepted by the text display builder constructor. */
+export type MiniTextDisplayBuilderData = Partial<MiniTextDisplayComponent>;
+/** Data accepted by the separator builder constructor. */
+export type MiniSeparatorBuilderData = Partial<MiniSeparatorComponent>;
+/** Data accepted by the gallery builder constructor. */
+export type MiniGalleryBuilderData = Partial<Omit<MiniGalleryComponent, "items">> & {
+    items?: Array<MiniGalleryItemComponent | JSONEncodable<MiniGalleryItemComponent>>;
+};
+/** Data accepted by the gallery item builder constructor. */
+export type MiniGalleryItemBuilderData = Partial<MiniGalleryItemComponent>;
+/** Data accepted by the thumbnail builder constructor. */
+export type MiniThumbnailBuilderData = Partial<MiniThumbnailComponent>;
+/** Builder for structured message container payloads. */
+export declare class MiniContainerBuilder implements JSONEncodable<MiniContainerComponent> {
+    private data;
+    constructor(data?: MiniContainerBuilderData);
+    /** Replaces the components contained in the container. */
+    setComponents(components: Array<MiniContentComponent | JSONEncodable<MiniContentComponent>>): this;
+    /** Replaces the sections contained in the container. */
+    setSections(sections: Array<MiniSectionComponent | JSONEncodable<MiniSectionComponent>>): this;
+    /** Adds a component to the container. */
+    addComponent(component: MiniContentComponent | JSONEncodable<MiniContentComponent>): this;
+    /** Adds a section to the container. */
+    addSection(section: MiniSectionComponent | JSONEncodable<MiniSectionComponent>): this;
+    /** Sets or clears the accent colour on the container. */
+    setAccentColor(color: number | null | undefined): this;
+    /** Marks the container as a spoiler. */
+    setSpoiler(spoiler: boolean | null | undefined): this;
+    /** Serialises the container into a structured message payload. */
+    toJSON(): MiniContainerComponent;
+}
+/** Builder for structured message sections. */
+export declare class MiniSectionBuilder implements JSONEncodable<MiniSectionComponent> {
+    private data;
+    constructor(data?: MiniSectionBuilderData);
+    /** Replaces the text components within the section. */
+    setComponents(components: Array<MiniTextDisplayComponent | JSONEncodable<MiniTextDisplayComponent>>): this;
+    /** Adds a text component to the section. */
+    addComponent(component: MiniTextDisplayComponent | JSONEncodable<MiniTextDisplayComponent>): this;
+    /** Sets or clears the accessory component. */
+    setAccessory(accessory: MiniSectionAccessoryComponent | JSONEncodable<MiniSectionAccessoryComponent> | null | undefined): this;
+    /** Serialises the section into a structured message payload. */
+    toJSON(): MiniSectionComponent;
+}
+/** Builder for structured message text display components. */
+export declare class MiniTextDisplayBuilder implements JSONEncodable<MiniTextDisplayComponent> {
+    private data;
+    constructor(data?: MiniTextDisplayBuilderData);
+    /** Sets or clears the primary text content. */
+    setContent(content: string | null | undefined): this;
+    /** Serialises the component into a structured message payload. */
+    toJSON(): MiniTextDisplayComponent;
+}
+/** Builder for structured message separator components. */
+export declare class MiniSeparatorBuilder implements JSONEncodable<MiniSeparatorComponent> {
+    private data;
+    constructor(data?: MiniSeparatorBuilderData);
+    /** Sets whether the separator should render a divider. */
+    setDivider(divider: boolean | null | undefined): this;
+    /** Sets the separator spacing value. */
+    setSpacing(spacing: SeparatorSpacingSize | null | undefined): this;
+    /** Serialises the separator payload. */
+    toJSON(): MiniSeparatorComponent;
+}
+/** Builder for structured message thumbnails. */
+export declare class MiniThumbnailBuilder implements JSONEncodable<MiniThumbnailComponent> {
+    private data;
+    constructor(data?: MiniThumbnailBuilderData);
+    /** Sets the media payload for the thumbnail. */
+    setMedia(media: APIUnfurledMediaItem | null | undefined): this;
+    /** Sets the thumbnail description. */
+    setDescription(description: string | null | undefined): this;
+    /** Marks the thumbnail as a spoiler. */
+    setSpoiler(spoiler: boolean | null | undefined): this;
+    /** Serialises the thumbnail payload. */
+    toJSON(): MiniThumbnailComponent;
+}
+/** Builder for structured message gallery items. */
+export declare class MiniGalleryItemBuilder implements JSONEncodable<MiniGalleryItemComponent> {
+    private data;
+    constructor(data?: MiniGalleryItemBuilderData);
+    /** Sets the media item payload. */
+    setMedia(media: APIUnfurledMediaItem | null | undefined): this;
+    /** Sets the media description. */
+    setDescription(description: string | null | undefined): this;
+    /** Marks the media item as a spoiler. */
+    setSpoiler(spoiler: boolean | null | undefined): this;
+    /** Serialises the gallery item payload. */
+    toJSON(): MiniGalleryItemComponent;
+}
+/** Builder for structured message gallery components. */
+export declare class MiniGalleryBuilder implements JSONEncodable<MiniGalleryComponent> {
+    private data;
+    constructor(data?: MiniGalleryBuilderData);
+    /** Replaces the gallery items. */
+    setItems(items: Array<MiniGalleryItemComponent | JSONEncodable<MiniGalleryItemComponent>>): this;
+    /** Adds a gallery item to the payload. */
+    addItem(item: MiniGalleryItemComponent | JSONEncodable<MiniGalleryItemComponent>): this;
+    /** Serialises the gallery payload. */
+    toJSON(): MiniGalleryComponent;
+}

package/dist/builders/MiniContainerBuilder.js

@@ -0,0 +1,345 @@
+import { ComponentType } from "discord-api-types/v10";
+import { resolveJSONEncodable } from "./shared.js";
+function cloneContainerComponent(component) {
+    const resolved = resolveJSONEncodable(component);
+    return { ...resolved };
+}
+function cloneAccessory(accessory) {
+    const resolved = resolveJSONEncodable(accessory);
+    return { ...resolved };
+}
+/** Builder for structured message container payloads. */
+export class MiniContainerBuilder {
+    data;
+    constructor(data = {}) {
+        const components = data.components
+            ? data.components.map((component) => cloneContainerComponent(component))
+            : [];
+        this.data = {
+            ...data,
+            type: ComponentType.Container,
+            components,
+        };
+    }
+    /** Replaces the components contained in the container. */
+    setComponents(components) {
+        this.data.components = components.map((component) => cloneContainerComponent(component));
+        return this;
+    }
+    /** Replaces the sections contained in the container. */
+    setSections(sections) {
+        return this.setComponents(sections);
+    }
+    /** Adds a component to the container. */
+    addComponent(component) {
+        this.data.components ??= [];
+        this.data.components.push(cloneContainerComponent(component));
+        return this;
+    }
+    /** Adds a section to the container. */
+    addSection(section) {
+        return this.addComponent(section);
+    }
+    /** Sets or clears the accent colour on the container. */
+    setAccentColor(color) {
+        if (color === undefined) {
+            delete this.data.accent_color;
+        }
+        else {
+            this.data.accent_color = color ?? null;
+        }
+        return this;
+    }
+    /** Marks the container as a spoiler. */
+    setSpoiler(spoiler) {
+        if (spoiler === null || spoiler === undefined) {
+            delete this.data.spoiler;
+        }
+        else {
+            this.data.spoiler = spoiler;
+        }
+        return this;
+    }
+    /** Serialises the container into a structured message payload. */
+    toJSON() {
+        const components = this.data.components ?? [];
+        return {
+            ...this.data,
+            type: ComponentType.Container,
+            components: components.map((component) => ({ ...component })),
+        };
+    }
+}
+/** Builder for structured message sections. */
+export class MiniSectionBuilder {
+    data;
+    constructor(data = {}) {
+        const components = data.components
+            ? data.components.map((component) => cloneTextDisplayComponent(component))
+            : [];
+        const rawAccessory = data.accessory;
+        const accessory = rawAccessory === undefined || rawAccessory === null
+            ? undefined
+            : cloneAccessory(rawAccessory);
+        this.data = {
+            ...data,
+            type: ComponentType.Section,
+            components,
+            accessory,
+        };
+    }
+    /** Replaces the text components within the section. */
+    setComponents(components) {
+        this.data.components = components.map((component) => cloneTextDisplayComponent(component));
+        return this;
+    }
+    /** Adds a text component to the section. */
+    addComponent(component) {
+        this.data.components ??= [];
+        this.data.components.push(cloneTextDisplayComponent(component));
+        return this;
+    }
+    /** Sets or clears the accessory component. */
+    setAccessory(accessory) {
+        if (accessory === null || accessory === undefined) {
+            this.data.accessory = undefined;
+        }
+        else {
+            this.data.accessory = cloneAccessory(accessory);
+        }
+        return this;
+    }
+    /** Serialises the section into a structured message payload. */
+    toJSON() {
+        const components = this.data.components ?? [];
+        const accessory = this.data.accessory ? { ...this.data.accessory } : undefined;
+        if (!accessory) {
+            throw new Error("[MiniSectionBuilder] accessory is required for sections");
+        }
+        return {
+            ...this.data,
+            type: ComponentType.Section,
+            components: components.map((component) => ({ ...component })),
+            accessory,
+        };
+    }
+}
+function cloneTextDisplayComponent(component) {
+    const resolved = resolveJSONEncodable(component);
+    return { ...resolved };
+}
+/** Builder for structured message text display components. */
+export class MiniTextDisplayBuilder {
+    data;
+    constructor(data = {}) {
+        this.data = {
+            ...data,
+            type: ComponentType.TextDisplay,
+        };
+    }
+    /** Sets or clears the primary text content. */
+    setContent(content) {
+        if (content === null || content === undefined) {
+            delete this.data.content;
+        }
+        else {
+            this.data.content = content;
+        }
+        return this;
+    }
+    /** Serialises the component into a structured message payload. */
+    toJSON() {
+        if (!this.data.content) {
+            throw new Error("[MiniTextDisplayBuilder] content is required for text displays");
+        }
+        return {
+            ...this.data,
+            type: ComponentType.TextDisplay,
+        };
+    }
+}
+/** Builder for structured message separator components. */
+export class MiniSeparatorBuilder {
+    data;
+    constructor(data = {}) {
+        this.data = {
+            ...data,
+            type: ComponentType.Separator,
+        };
+    }
+    /** Sets whether the separator should render a divider. */
+    setDivider(divider) {
+        if (divider === null || divider === undefined) {
+            delete this.data.divider;
+        }
+        else {
+            this.data.divider = divider;
+        }
+        return this;
+    }
+    /** Sets the separator spacing value. */
+    setSpacing(spacing) {
+        if (spacing === null || spacing === undefined) {
+            delete this.data.spacing;
+        }
+        else {
+            this.data.spacing = spacing;
+        }
+        return this;
+    }
+    /** Serialises the separator payload. */
+    toJSON() {
+        return {
+            ...this.data,
+            type: ComponentType.Separator,
+        };
+    }
+}
+/** Builder for structured message thumbnails. */
+export class MiniThumbnailBuilder {
+    data;
+    constructor(data = {}) {
+        this.data = {
+            ...data,
+            type: ComponentType.Thumbnail,
+            media: data.media ? { ...data.media } : undefined,
+        };
+    }
+    /** Sets the media payload for the thumbnail. */
+    setMedia(media) {
+        if (media === null || media === undefined) {
+            delete this.data.media;
+        }
+        else {
+            this.data.media = { ...media };
+        }
+        return this;
+    }
+    /** Sets the thumbnail description. */
+    setDescription(description) {
+        if (description === null || description === undefined) {
+            delete this.data.description;
+        }
+        else {
+            this.data.description = description;
+        }
+        return this;
+    }
+    /** Marks the thumbnail as a spoiler. */
+    setSpoiler(spoiler) {
+        if (spoiler === null || spoiler === undefined) {
+            delete this.data.spoiler;
+        }
+        else {
+            this.data.spoiler = spoiler;
+        }
+        return this;
+    }
+    /** Serialises the thumbnail payload. */
+    toJSON() {
+        if (!this.data.media) {
+            throw new Error("[MiniThumbnailBuilder] media is required for thumbnails");
+        }
+        return {
+            ...this.data,
+            type: ComponentType.Thumbnail,
+        };
+    }
+}
+/** Builder for structured message gallery items. */
+export class MiniGalleryItemBuilder {
+    data;
+    constructor(data = {}) {
+        this.data = {
+            ...data,
+            media: data.media ? { ...data.media } : undefined,
+        };
+    }
+    /** Sets the media item payload. */
+    setMedia(media) {
+        if (media === null || media === undefined) {
+            delete this.data.media;
+        }
+        else {
+            this.data.media = { ...media };
+        }
+        return this;
+    }
+    /** Sets the media description. */
+    setDescription(description) {
+        if (description === null || description === undefined) {
+            delete this.data.description;
+        }
+        else {
+            this.data.description = description;
+        }
+        return this;
+    }
+    /** Marks the media item as a spoiler. */
+    setSpoiler(spoiler) {
+        if (spoiler === null || spoiler === undefined) {
+            delete this.data.spoiler;
+        }
+        else {
+            this.data.spoiler = spoiler;
+        }
+        return this;
+    }
+    /** Serialises the gallery item payload. */
+    toJSON() {
+        if (!this.data.media) {
+            throw new Error("[MiniGalleryItemBuilder] media is required for gallery items");
+        }
+        return {
+            ...this.data,
+            media: { ...this.data.media },
+        };
+    }
+}
+/** Builder for structured message gallery components. */
+export class MiniGalleryBuilder {
+    data;
+    constructor(data = {}) {
+        const items = data.items
+            ? data.items.map((item) => resolveGalleryItem(item))
+            : [];
+        this.data = {
+            ...data,
+            type: ComponentType.MediaGallery,
+            items,
+        };
+    }
+    /** Replaces the gallery items. */
+    setItems(items) {
+        this.data.items = items.map((item) => resolveGalleryItem(item));
+        return this;
+    }
+    /** Adds a gallery item to the payload. */
+    addItem(item) {
+        this.data.items ??= [];
+        this.data.items.push(resolveGalleryItem(item));
+        return this;
+    }
+    /** Serialises the gallery payload. */
+    toJSON() {
+        const items = this.data.items ?? [];
+        if (items.length === 0) {
+            throw new Error("[MiniGalleryBuilder] at least one gallery item is required");
+        }
+        return {
+            ...this.data,
+            type: ComponentType.MediaGallery,
+            items: items.map((item) => ({ ...item })),
+        };
+    }
+}
+function resolveGalleryItem(item) {
+    const resolved = resolveJSONEncodable(item);
+    if (!resolved.media) {
+        throw new Error("[MiniGalleryBuilder] gallery items require media");
+    }
+    return {
+        ...resolved,
+        media: { ...resolved.media },
+    };
+}

package/dist/builders/index.d.ts

@@ -11,4 +11,10 @@ export { ChannelSelectMenuBuilder } from "./ChannelSelectMenuBuilder.js";
 export type { ChannelSelectMenuBuilderData } from "./ChannelSelectMenuBuilder.js";
 export { ModalBuilder } from "./ModalBuilder.js";
 export type { ModalBuilderData, ModalComponentLike } from "./ModalBuilder.js";
+export { AutomodRuleBuilder } from "./AutomodRuleBuilder.js";
+export type { AutomodRuleBuilderData } from "./AutomodRuleBuilder.js";
+export { EmbedBuilder } from "./EmbedBuilder.js";
+export type { EmbedBuilderData } from "./EmbedBuilder.js";
+export { MiniContainerBuilder, MiniSectionBuilder, MiniTextDisplayBuilder, MiniSeparatorBuilder, MiniGalleryBuilder, MiniGalleryItemBuilder, MiniThumbnailBuilder, } from "./MiniContainerBuilder.js";
+export type { MiniContainerBuilderData, MiniSectionBuilderData, MiniTextDisplayBuilderData, MiniSeparatorBuilderData, MiniGalleryBuilderData, MiniGalleryItemBuilderData, MiniThumbnailBuilderData, MiniContainerComponent, MiniSectionComponent, MiniTextDisplayComponent, MiniSeparatorComponent, MiniGalleryComponent, MiniGalleryItemComponent, MiniThumbnailComponent, MiniContentComponent, MiniSectionAccessoryComponent, } from "./MiniContainerBuilder.js";
 export type { JSONEncodable } from "./shared.js";

package/dist/builders/index.js

@@ -5,3 +5,6 @@ export { StringSelectMenuBuilder } from "./StringSelectMenuBuilder.js";
 export { RoleSelectMenuBuilder } from "./RoleSelectMenuBuilder.js";
 export { ChannelSelectMenuBuilder } from "./ChannelSelectMenuBuilder.js";
 export { ModalBuilder } from "./ModalBuilder.js";
+export { AutomodRuleBuilder } from "./AutomodRuleBuilder.js";
+export { EmbedBuilder } from "./EmbedBuilder.js";
+export { MiniContainerBuilder, MiniSectionBuilder, MiniTextDisplayBuilder, MiniSeparatorBuilder, MiniGalleryBuilder, MiniGalleryItemBuilder, MiniThumbnailBuilder, } from "./MiniContainerBuilder.js";

package/dist/clients/MiniInteraction.d.ts

@@ -8,6 +8,7 @@ export type MiniInteractionOptions = {
     applicationId: string;
     publicKey: string;
     commandsDirectory?: string | false;
+    componentsDirectory?: string | false;
     fetchImplementation?: typeof fetch;
     verifyKeyImplementation?: VerifyKeyFunction;
 };
@@ -58,14 +59,17 @@ export declare class MiniInteraction {
     private readonly fetchImpl;
     private readonly verifyKeyImpl;
     private readonly commandsDirectory;
+    private readonly componentsDirectory;
     private readonly commands;
     private readonly componentHandlers;
     private commandsLoaded;
     private loadCommandsPromise;
+    private componentsLoaded;
+    private loadComponentsPromise;
     /**
      * Creates a new MiniInteraction client with optional command auto-loading and custom runtime hooks.
      */
-    constructor({ applicationId, publicKey, commandsDirectory, fetchImplementation, verifyKeyImplementation, }: MiniInteractionOptions);
+    constructor({ applicationId, publicKey, commandsDirectory, componentsDirectory, fetchImplementation, verifyKeyImplementation, }: MiniInteractionOptions);
     /**
      * Registers a single command handler with the client.
      *
@@ -90,6 +94,12 @@ export declare class MiniInteraction {
      * @param components - The component definitions to register.
      */
     useComponents(components: MiniInteractionComponent[]): this;
+    /**
+     * Recursively loads components from the configured components directory.
+     *
+     * @param directory - Optional directory override for component discovery.
+     */
+    loadComponentsFromDirectory(directory?: string): Promise<this>;
     /**
      * Recursively loads commands from the configured commands directory.
      *
@@ -143,19 +153,27 @@ export declare class MiniInteraction {
     /**
      * Recursively collects all command module file paths from the target directory.
      */
-    private collectCommandFiles;
+    private collectModuleFiles;
     /**
      * Determines whether the provided file path matches a supported command file extension.
      */
-    private isSupportedCommandFile;
+    private isSupportedModuleFile;
     /**
      * Dynamically imports and validates a command module from disk.
      */
     private importCommandModule;
+    /**
+     * Dynamically imports and validates a component module from disk.
+     */
+    private importComponentModule;
     /**
      * Normalises the request body into a UTF-8 string for signature validation and parsing.
      */
     private normalizeBody;
+    /**
+     * Ensures components have been loaded from disk once before being accessed.
+     */
+    private ensureComponentsLoaded;
     /**
      * Ensures commands have been loaded from disk once before being accessed.
      */

package/dist/clients/MiniInteraction.js

@@ -7,8 +7,8 @@ import { verifyKey } from "discord-interactions";
 import { DISCORD_BASE_URL } from "../utils/constants.js";
 import { createCommandInteraction } from "../utils/CommandInteractionOptions.js";
 import { createMessageComponentInteraction, } from "../utils/MessageComponentInteraction.js";
-/** File extensions that are treated as command modules when auto-loading. */
-const SUPPORTED_COMMAND_EXTENSIONS = new Set([
+/** File extensions that are treated as loadable modules when auto-loading. */
+const SUPPORTED_MODULE_EXTENSIONS = new Set([
     ".js",
     ".mjs",
     ".cjs",
@@ -26,14 +26,17 @@ export class MiniInteraction {
     fetchImpl;
     verifyKeyImpl;
     commandsDirectory;
+    componentsDirectory;
     commands = new Map();
     componentHandlers = new Map();
     commandsLoaded = false;
     loadCommandsPromise = null;
+    componentsLoaded = false;
+    loadComponentsPromise = null;
     /**
      * Creates a new MiniInteraction client with optional command auto-loading and custom runtime hooks.
      */
-    constructor({ applicationId, publicKey, commandsDirectory, fetchImplementation, verifyKeyImplementation, }) {
+    constructor({ applicationId, publicKey, commandsDirectory, componentsDirectory, fetchImplementation, verifyKeyImplementation, }) {
         if (!applicationId) {
             throw new Error("[MiniInteraction] applicationId is required");
         }
@@ -53,6 +56,10 @@ export class MiniInteraction {
             commandsDirectory === false
                 ? null
                 : this.resolveCommandsDirectory(commandsDirectory);
+        this.componentsDirectory =
+            componentsDirectory === false
+                ? null
+                : this.resolveComponentsDirectory(componentsDirectory);
     }
     /**
      * Registers a single command handler with the client.
@@ -111,6 +118,42 @@ export class MiniInteraction {
         }
         return this;
     }
+    /**
+     * Recursively loads components from the configured components directory.
+     *
+     * @param directory - Optional directory override for component discovery.
+     */
+    async loadComponentsFromDirectory(directory) {
+        const targetDirectory = directory !== undefined
+            ? this.resolveComponentsDirectory(directory)
+            : this.componentsDirectory;
+        if (!targetDirectory) {
+            throw new Error("[MiniInteraction] Components directory support disabled. Provide a directory path.");
+        }
+        const exists = await this.pathExists(targetDirectory);
+        if (!exists) {
+            this.componentsLoaded = true;
+            console.warn(`[MiniInteraction] Components directory "${targetDirectory}" does not exist. Skipping component auto-load.`);
+            return this;
+        }
+        const files = await this.collectModuleFiles(targetDirectory);
+        if (files.length === 0) {
+            this.componentsLoaded = true;
+            console.warn(`[MiniInteraction] No component files found under "${targetDirectory}".`);
+            return this;
+        }
+        for (const file of files) {
+            const components = await this.importComponentModule(file);
+            if (components.length === 0) {
+                continue;
+            }
+            for (const component of components) {
+                this.useComponent(component);
+            }
+        }
+        this.componentsLoaded = true;
+        return this;
+    }
     /**
      * Recursively loads commands from the configured commands directory.
      *
@@ -129,7 +172,7 @@ export class MiniInteraction {
             console.warn(`[MiniInteraction] Commands directory "${targetDirectory}" does not exist. Skipping command auto-load.`);
             return this;
         }
-        const files = await this.collectCommandFiles(targetDirectory);
+        const files = await this.collectModuleFiles(targetDirectory);
         if (files.length === 0) {
             this.commandsLoaded = true;
             console.warn(`[MiniInteraction] No command files found under "${targetDirectory}".`);
@@ -385,7 +428,7 @@ export class MiniInteraction {
     /**
      * Recursively collects all command module file paths from the target directory.
      */
-    async collectCommandFiles(directory) {
+    async collectModuleFiles(directory) {
         const entries = await readdir(directory, { withFileTypes: true });
         const files = [];
         for (const entry of entries) {
@@ -394,11 +437,11 @@ export class MiniInteraction {
             }
             const fullPath = path.join(directory, entry.name);
             if (entry.isDirectory()) {
-                const nestedFiles = await this.collectCommandFiles(fullPath);
+                const nestedFiles = await this.collectModuleFiles(fullPath);
                 files.push(...nestedFiles);
                 continue;
             }
-            if (entry.isFile() && this.isSupportedCommandFile(fullPath)) {
+            if (entry.isFile() && this.isSupportedModuleFile(fullPath)) {
                 files.push(fullPath);
             }
         }
@@ -407,8 +450,8 @@ export class MiniInteraction {
     /**
      * Determines whether the provided file path matches a supported command file extension.
      */
-    isSupportedCommandFile(filePath) {
-        return SUPPORTED_COMMAND_EXTENSIONS.has(path.extname(filePath).toLowerCase());
+    isSupportedModuleFile(filePath) {
+        return SUPPORTED_MODULE_EXTENSIONS.has(path.extname(filePath).toLowerCase());
     }
     /**
      * Dynamically imports and validates a command module from disk.
@@ -441,6 +484,47 @@ export class MiniInteraction {
             return null;
         }
     }
+    /**
+     * Dynamically imports and validates a component module from disk.
+     */
+    async importComponentModule(absolutePath) {
+        try {
+            const moduleUrl = pathToFileURL(absolutePath).href;
+            const imported = await import(moduleUrl);
+            const candidate = imported.default ??
+                imported.component ??
+                imported.components ??
+                imported.componentDefinition ??
+                imported;
+            const candidates = Array.isArray(candidate)
+                ? candidate
+                : [candidate];
+            const components = [];
+            for (const item of candidates) {
+                if (!item || typeof item !== "object") {
+                    continue;
+                }
+                const { customId, handler } = item;
+                if (typeof customId !== "string") {
+                    console.warn(`[MiniInteraction] Component module "${absolutePath}" is missing "customId". Skipping.`);
+                    continue;
+                }
+                if (typeof handler !== "function") {
+                    console.warn(`[MiniInteraction] Component module "${absolutePath}" is missing a "handler" function. Skipping.`);
+                    continue;
+                }
+                components.push({ customId, handler });
+            }
+            if (components.length === 0) {
+                console.warn(`[MiniInteraction] Component module "${absolutePath}" did not export any valid components. Skipping.`);
+            }
+            return components;
+        }
+        catch (error) {
+            console.error(`[MiniInteraction] Failed to load component module "${absolutePath}":`, error);
+            return [];
+        }
+    }
     /**
      * Normalises the request body into a UTF-8 string for signature validation and parsing.
      */
@@ -450,6 +534,20 @@ export class MiniInteraction {
         }
         return Buffer.from(body).toString("utf8");
     }
+    /**
+     * Ensures components have been loaded from disk once before being accessed.
+     */
+    async ensureComponentsLoaded() {
+        if (this.componentsLoaded || this.componentsDirectory === null) {
+            return;
+        }
+        if (!this.loadComponentsPromise) {
+            this.loadComponentsPromise = this.loadComponentsFromDirectory().then(() => {
+                this.loadComponentsPromise = null;
+            });
+        }
+        await this.loadComponentsPromise;
+    }
     /**
      * Ensures commands have been loaded from disk once before being accessed.
      */
@@ -546,6 +644,7 @@ export class MiniInteraction {
                 },
             };
         }
+        await this.ensureComponentsLoaded();
         const handler = this.componentHandlers.get(customId);
         if (!handler) {
             return {

package/dist/index.d.ts

@@ -12,5 +12,6 @@ export { RoleConnectionMetadataTypes } from "./types/RoleConnectionMetadataTypes
 export { ChannelType } from "./types/ChannelType.js";
 export { InteractionFollowUpFlags, InteractionReplyFlags, } from "./types/InteractionFlags.js";
 export { ButtonStyle } from "./types/ButtonStyle.js";
+export { MiniPermFlags } from "./types/PermissionFlags.js";
 export type { MiniComponentActionRow, MiniComponentMessageActionRow, } from "./types/ComponentTypes.js";
 export * from "./builders/index.js";

package/dist/index.js

@@ -6,4 +6,5 @@ export { RoleConnectionMetadataTypes } from "./types/RoleConnectionMetadataTypes
 export { ChannelType } from "./types/ChannelType.js";
 export { InteractionFollowUpFlags, InteractionReplyFlags, } from "./types/InteractionFlags.js";
 export { ButtonStyle } from "./types/ButtonStyle.js";
+export { MiniPermFlags } from "./types/PermissionFlags.js";
 export * from "./builders/index.js";

package/dist/types/PermissionFlags.d.ts

@@ -0,0 +1,55 @@
+/** Convenience mapping of Discord permission bit flags for MiniInteraction usage. */
+export declare const MiniPermFlags: {
+    readonly CreateInstantInvite: bigint;
+    readonly KickMembers: bigint;
+    readonly BanMembers: bigint;
+    readonly Administrator: bigint;
+    readonly ManageChannels: bigint;
+    readonly ManageGuild: bigint;
+    readonly AddReactions: bigint;
+    readonly ViewAuditLog: bigint;
+    readonly PrioritySpeaker: bigint;
+    readonly Stream: bigint;
+    readonly ViewChannel: bigint;
+    readonly SendMessages: bigint;
+    readonly SendTTSMessages: bigint;
+    readonly ManageMessages: bigint;
+    readonly EmbedLinks: bigint;
+    readonly AttachFiles: bigint;
+    readonly ReadMessageHistory: bigint;
+    readonly MentionEveryone: bigint;
+    readonly UseExternalEmojis: bigint;
+    readonly ViewGuildInsights: bigint;
+    readonly Connect: bigint;
+    readonly Speak: bigint;
+    readonly MuteMembers: bigint;
+    readonly DeafenMembers: bigint;
+    readonly MoveMembers: bigint;
+    readonly UseVAD: bigint;
+    readonly ChangeNickname: bigint;
+    readonly ManageNicknames: bigint;
+    readonly ManageRoles: bigint;
+    readonly ManageWebhooks: bigint;
+    readonly ManageEmojisAndStickers: bigint;
+    readonly ManageGuildExpressions: bigint;
+    readonly UseApplicationCommands: bigint;
+    readonly RequestToSpeak: bigint;
+    readonly ManageEvents: bigint;
+    readonly ManageThreads: bigint;
+    readonly CreatePublicThreads: bigint;
+    readonly CreatePrivateThreads: bigint;
+    readonly UseExternalStickers: bigint;
+    readonly SendMessagesInThreads: bigint;
+    readonly UseEmbeddedActivities: bigint;
+    readonly ModerateMembers: bigint;
+    readonly ViewCreatorMonetizationAnalytics: bigint;
+    readonly UseSoundboard: bigint;
+    readonly CreateGuildExpressions: bigint;
+    readonly CreateEvents: bigint;
+    readonly UseExternalSounds: bigint;
+    readonly SendVoiceMessages: bigint;
+    readonly SendPolls: bigint;
+    readonly UseExternalApps: bigint;
+    readonly PinMessages: bigint;
+};
+export type MiniPermFlag = (typeof MiniPermFlags)[keyof typeof MiniPermFlags];

package/dist/types/PermissionFlags.js

@@ -0,0 +1,5 @@
+import { PermissionFlagsBits } from "discord-api-types/v10";
+/** Convenience mapping of Discord permission bit flags for MiniInteraction usage. */
+export const MiniPermFlags = {
+    ...PermissionFlagsBits,
+};

package/dist/utils/interactionMessageHelpers.js

@@ -1,3 +1,13 @@
+import { ComponentType, MessageFlags as RawMessageFlags } from "discord-api-types/v10";
+const COMPONENTS_V2_TYPES = new Set([
+    ComponentType.Container,
+    ComponentType.Section,
+    ComponentType.TextDisplay,
+    ComponentType.MediaGallery,
+    ComponentType.File,
+    ComponentType.Separator,
+    ComponentType.Thumbnail,
+]);
 /**
  * Normalises helper flag enums into the raw Discord `MessageFlags` bitfield.
  *
@@ -17,16 +27,51 @@ export function normaliseInteractionMessageData(data) {
     if (!data) {
         return undefined;
     }
-    if (data.flags === undefined) {
-        return data;
-    }
-    const { flags, ...rest } = data;
-    const normalisedFlags = normaliseMessageFlags(flags);
-    if (normalisedFlags === flags) {
+    const usesComponentsV2 = Array.isArray(data.components)
+        ? containsComponentsV2(data.components)
+        : false;
+    const normalisedFlags = normaliseMessageFlags(data.flags);
+    const finalFlags = usesComponentsV2
+        ? ((normalisedFlags ?? 0) | RawMessageFlags.IsComponentsV2)
+        : normalisedFlags;
+    if (finalFlags === data.flags) {
         return data;
     }
+    const { flags: _flags, ...rest } = data;
     return {
         ...rest,
-        flags: normalisedFlags,
+        ...(finalFlags !== undefined ? { flags: finalFlags } : {}),
     };
 }
+function containsComponentsV2(components) {
+    return components.some((component) => componentUsesComponentsV2(component));
+}
+function componentUsesComponentsV2(component) {
+    const resolved = resolveComponentLike(component);
+    if (!resolved || typeof resolved !== "object") {
+        return false;
+    }
+    const type = resolved.type;
+    if (typeof type !== "number") {
+        return false;
+    }
+    if (COMPONENTS_V2_TYPES.has(type)) {
+        return true;
+    }
+    if (type === ComponentType.ActionRow) {
+        const rowComponents = resolved.components;
+        if (Array.isArray(rowComponents)) {
+            return containsComponentsV2(rowComponents);
+        }
+    }
+    return false;
+}
+function resolveComponentLike(component) {
+    if (component && typeof component === "object" && "toJSON" in component) {
+        const encoder = component;
+        if (typeof encoder.toJSON === "function") {
+            return encoder.toJSON();
+        }
+    }
+    return component;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@minesa-org/mini-interaction",
-	"version": "0.0.3",
+	"version": "0.0.5",
 	"description": "Mini interaction, connecting your app with Discord via HTTP-interaction (Vercel support).",
 	"type": "module",
 	"main": "dist/index.js",