@jubbio/core 1.1.20 → 1.3.2

package/dist/cjs/structures/Message.js

@@ -0,0 +1,195 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Message = void 0;
+const User_1 = require("./User");
+const Collector_1 = require("../utils/Collector");
+const EmbedBuilder_1 = require("../builders/EmbedBuilder");
+/** Backend flat embed format (for normalization) */
+/** Resolve EmbedBuilder instances to plain API objects */
+function resolveEmbeds(embeds) {
+    if (!embeds)
+        return undefined;
+    return embeds.map(e => e instanceof EmbedBuilder_1.EmbedBuilder ? e.toJSON() : e);
+}
+/** Normalize embed from backend to APIEmbed format */
+function normalizeEmbed(embed) {
+    const normalized = {
+        title: embed.title,
+        description: embed.description,
+        url: embed.url,
+        timestamp: embed.timestamp,
+        color: embed.color,
+        fields: embed.fields,
+        author: embed.author,
+        footer: embed.footer,
+    };
+    // Normalize thumbnail: string → nested object
+    if (typeof embed.thumbnail === 'string') {
+        normalized.thumbnail = { url: embed.thumbnail };
+    }
+    else if (embed.thumbnail && typeof embed.thumbnail === 'object') {
+        normalized.thumbnail = embed.thumbnail;
+    }
+    // Normalize image: string → nested object
+    if (typeof embed.image === 'string') {
+        normalized.image = { url: embed.image };
+    }
+    else if (embed.image && typeof embed.image === 'object') {
+        normalized.image = embed.image;
+    }
+    return normalized;
+}
+/**
+ * Represents a message
+ */
+class Message {
+    /** Reference to the client */
+    client;
+    /** Message ID */
+    id;
+    /** Channel ID */
+    channelId;
+    /** Guild ID (if in a guild) */
+    guildId;
+    /** Message author */
+    author;
+    /** Message content */
+    content;
+    /** Message timestamp */
+    createdTimestamp;
+    /** Edit timestamp */
+    editedTimestamp;
+    /** Attachments */
+    attachments;
+    /** Embeds */
+    embeds;
+    /** Components (buttons, select menus, etc.) */
+    components;
+    /** Mentions in the message */
+    mentions;
+    /** User ID (from backend) */
+    user_id;
+    /** Guild member (if in a guild) */
+    member;
+    constructor(client, data) {
+        this.client = client;
+        this.id = data.id;
+        this.channelId = data.channel_id;
+        this.guildId = data.guild_id;
+        this.author = new User_1.User(data.author);
+        this.content = data.content ?? '';
+        // Handle different timestamp formats from backend
+        const timestamp = data.timestamp || data.created_at;
+        this.createdTimestamp = timestamp ? new Date(timestamp).getTime() : Date.now();
+        const editedTimestamp = data.edited_timestamp || data.updated_at;
+        this.editedTimestamp = editedTimestamp ? new Date(editedTimestamp).getTime() : undefined;
+        this.attachments = data.attachments || [];
+        // Normalize embeds from backend (flat format → nested format)
+        this.embeds = data.embeds ? data.embeds.map(normalizeEmbed) : [];
+        // Components (ActionRows with buttons, select menus, etc.)
+        this.components = data.components || [];
+        this.mentions = data.mentions || {};
+        this.user_id = data.user_id;
+    }
+    /**
+     * Get the creation date
+     */
+    get createdAt() {
+        return new Date(this.createdTimestamp);
+    }
+    /**
+     * Get the edit date
+     */
+    get editedAt() {
+        return this.editedTimestamp ? new Date(this.editedTimestamp) : null;
+    }
+    /**
+     * Reply to this message
+     */
+    async reply(options) {
+        const content = typeof options === 'string' ? options : options.content;
+        const embeds = typeof options === 'string' ? undefined : resolveEmbeds(options.embeds);
+        const components = typeof options === 'string' ? undefined : options.components;
+        const data = await this.client.rest.createMessage(this.guildId || '', this.channelId, {
+            content,
+            embeds,
+            components,
+            message_reference: { message_id: this.id }
+        });
+        return new Message(this.client, data);
+    }
+    /**
+     * Edit this message (only if author is the bot)
+     */
+    async edit(options) {
+        const content = typeof options === 'string' ? options : options.content;
+        const embeds = typeof options === 'string' ? undefined : resolveEmbeds(options.embeds);
+        const components = typeof options === 'string' ? undefined : options.components;
+        const data = await this.client.rest.editMessage(this.guildId || '', this.channelId, this.id, {
+            content,
+            embeds,
+            components,
+        });
+        return new Message(this.client, data);
+    }
+    /**
+     * Delete this message
+     */
+    async delete() {
+        await this.client.rest.deleteMessage(this.guildId || '', this.channelId, this.id);
+    }
+    /**
+     * React to this message
+     */
+    async react(emoji) {
+        await this.client.rest.addReaction(this.guildId || '', this.channelId, this.id, emoji);
+    }
+    /**
+     * Pin this message
+     */
+    async pin() {
+        await this.client.rest.pinMessage(this.guildId || '', this.channelId, this.id);
+    }
+    /**
+     * Unpin this message
+     */
+    async unpin() {
+        await this.client.rest.unpinMessage(this.guildId || '', this.channelId, this.id);
+    }
+    /**
+     * Create a component interaction collector on this message
+     */
+    createMessageComponentCollector(options) {
+        return new Collector_1.InteractionCollector(this.client, {
+            ...options,
+            messageId: this.id,
+            channelId: this.channelId,
+            guildId: this.guildId,
+        });
+    }
+    /**
+     * Await component interactions on this message
+     */
+    awaitMessageComponent(options) {
+        return new Promise((resolve, reject) => {
+            const collector = this.createMessageComponentCollector({ ...options, max: 1 });
+            collector.once('end', (collected, reason) => {
+                const first = collected.first();
+                if (first) {
+                    resolve(first);
+                }
+                else {
+                    reject(new Error(reason || 'No interaction received'));
+                }
+            });
+        });
+    }
+    /**
+     * Convert to string
+     */
+    toString() {
+        return this.content;
+    }
+}
+exports.Message = Message;
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"Message.js","sourceRoot":"","sources":["../../../src/structures/Message.ts"],"names":[],"mappings":"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","sourcesContent":["import { APIMessage, APIEmbed, APIAttachment } from '../types';\r\nimport { User } from './User';\r\nimport { GuildMember } from './GuildMember';\r\nimport type { Client } from '../Client';\r\nimport type { MessageCreateOptions } from './Channel';\r\nimport { Collection } from './Collection';\r\nimport { InteractionCollector, InteractionCollectorOptions } from '../utils/Collector';\r\nimport { EmbedBuilder } from '../builders/EmbedBuilder';\r\n\r\n/** Backend flat embed format (for normalization) */\r\n/** Resolve EmbedBuilder instances to plain API objects */\r\nfunction resolveEmbeds(embeds?: (APIEmbed | EmbedBuilder)[]): APIEmbed[] | undefined {\r\n  if (!embeds) return undefined;\r\n  return embeds.map(e => e instanceof EmbedBuilder ? e.toJSON() : e);\r\n}\r\n\r\n/** Normalize embed from backend to APIEmbed format */\r\nfunction normalizeEmbed(embed: APIEmbed & { image?: { url: string } | string; thumbnail?: { url: string } | string }): APIEmbed {\r\n  const normalized: APIEmbed = {\r\n    title: embed.title,\r\n    description: embed.description,\r\n    url: embed.url,\r\n    timestamp: embed.timestamp,\r\n    color: embed.color,\r\n    fields: embed.fields,\r\n    author: embed.author,\r\n    footer: embed.footer,\r\n  };\r\n\r\n  // Normalize thumbnail: string → nested object\r\n  if (typeof embed.thumbnail === 'string') {\r\n    normalized.thumbnail = { url: embed.thumbnail };\r\n  } else if (embed.thumbnail && typeof embed.thumbnail === 'object') {\r\n    normalized.thumbnail = embed.thumbnail;\r\n  }\r\n\r\n  // Normalize image: string → nested object\r\n  if (typeof embed.image === 'string') {\r\n    normalized.image = { url: embed.image };\r\n  } else if (embed.image && typeof embed.image === 'object') {\r\n    normalized.image = embed.image;\r\n  }\r\n\r\n  return normalized;\r\n}\r\n\r\n/**\r\n * Mention data from backend\r\n */\r\nexport interface MessageMentions {\r\n  users?: Array<{ id: number | string; username: string }>;\r\n  roles?: Array<{ id: string; name?: string }>;\r\n  everyone?: boolean;\r\n}\r\n\r\n/**\r\n * Represents a message\r\n */\r\nexport class Message {\r\n  /** Reference to the client */\r\n  public readonly client: Client;\r\n  \r\n  /** Message ID */\r\n  public readonly id: string;\r\n  \r\n  /** Channel ID */\r\n  public readonly channelId: string;\r\n  \r\n  /** Guild ID (if in a guild) */\r\n  public readonly guildId?: string;\r\n  \r\n  /** Message author */\r\n  public readonly author: User;\r\n  \r\n  /** Message content */\r\n  public content: string;\r\n  \r\n  /** Message timestamp */\r\n  public readonly createdTimestamp: number;\r\n  \r\n  /** Edit timestamp */\r\n  public editedTimestamp?: number;\r\n  \r\n  /** Attachments */\r\n  public attachments: APIAttachment[];\r\n  \r\n  /** Embeds */\r\n  public embeds: APIEmbed[];\r\n\r\n  /** Components (buttons, select menus, etc.) */\r\n  public components: any[];\r\n\r\n  /** Mentions in the message */\r\n  public mentions: MessageMentions;\r\n\r\n  /** User ID (from backend) */\r\n  public user_id?: number;\r\n\r\n  /** Guild member (if in a guild) */\r\n  public member?: GuildMember;\r\n\r\n  constructor(client: Client, data: APIMessage) {\r\n    this.client = client;\r\n    this.id = data.id;\r\n    this.channelId = data.channel_id;\r\n    this.guildId = data.guild_id;\r\n    this.author = new User(data.author);\r\n    this.content = data.content ?? '';\r\n    \r\n    // Handle different timestamp formats from backend\r\n    const timestamp = data.timestamp || (data as any).created_at;\r\n    this.createdTimestamp = timestamp ? new Date(timestamp).getTime() : Date.now();\r\n    \r\n    const editedTimestamp = data.edited_timestamp || (data as any).updated_at;\r\n    this.editedTimestamp = editedTimestamp ? new Date(editedTimestamp).getTime() : undefined;\r\n    \r\n    this.attachments = data.attachments || [];\r\n    \r\n    // Normalize embeds from backend (flat format → nested format)\r\n    this.embeds = data.embeds ? data.embeds.map(normalizeEmbed) : [];\r\n    \r\n    // Components (ActionRows with buttons, select menus, etc.)\r\n    this.components = (data as any).components || [];\r\n    \r\n    this.mentions = (data as any).mentions || {};\r\n    this.user_id = (data as any).user_id;\r\n  }\r\n\r\n  /**\r\n   * Get the creation date\r\n   */\r\n  get createdAt(): Date {\r\n    return new Date(this.createdTimestamp);\r\n  }\r\n\r\n  /**\r\n   * Get the edit date\r\n   */\r\n  get editedAt(): Date | null {\r\n    return this.editedTimestamp ? new Date(this.editedTimestamp) : null;\r\n  }\r\n\r\n  /**\r\n   * Reply to this message\r\n   */\r\n  async reply(options: string | MessageCreateOptions): Promise<Message> {\r\n    const content = typeof options === 'string' ? options : options.content;\r\n    const embeds = typeof options === 'string' ? undefined : resolveEmbeds(options.embeds);\r\n    const components = typeof options === 'string' ? undefined : options.components;\r\n    \r\n    const data = await this.client.rest.createMessage(this.guildId || '', this.channelId, {\r\n      content,\r\n      embeds,\r\n      components,\r\n      message_reference: { message_id: this.id }\r\n    });\r\n    \r\n    return new Message(this.client, data);\r\n  }\r\n\r\n  /**\r\n   * Edit this message (only if author is the bot)\r\n   */\r\n  async edit(options: string | MessageCreateOptions): Promise<Message> {\r\n    const content = typeof options === 'string' ? options : options.content;\r\n    const embeds = typeof options === 'string' ? undefined : resolveEmbeds(options.embeds);\r\n    const components = typeof options === 'string' ? undefined : options.components;\r\n    \r\n    const data = await this.client.rest.editMessage(this.guildId || '', this.channelId, this.id, {\r\n      content,\r\n      embeds,\r\n      components,\r\n    });\r\n    \r\n    return new Message(this.client, data);\r\n  }\r\n\r\n  /**\r\n   * Delete this message\r\n   */\r\n  async delete(): Promise<void> {\r\n    await this.client.rest.deleteMessage(this.guildId || '', this.channelId, this.id);\r\n  }\r\n\r\n  /**\r\n   * React to this message\r\n   */\r\n  async react(emoji: string): Promise<void> {\r\n    await this.client.rest.addReaction(this.guildId || '', this.channelId, this.id, emoji);\r\n  }\r\n\r\n  /**\r\n   * Pin this message\r\n   */\r\n  async pin(): Promise<void> {\r\n    await this.client.rest.pinMessage(this.guildId || '', this.channelId, this.id);\r\n  }\r\n\r\n  /**\r\n   * Unpin this message\r\n   */\r\n  async unpin(): Promise<void> {\r\n    await this.client.rest.unpinMessage(this.guildId || '', this.channelId, this.id);\r\n  }\r\n\r\n  /**\r\n   * Create a component interaction collector on this message\r\n   */\r\n  createMessageComponentCollector(options?: Omit<InteractionCollectorOptions, 'messageId'>): InteractionCollector {\r\n    return new InteractionCollector(this.client, {\r\n      ...options,\r\n      messageId: this.id,\r\n      channelId: this.channelId,\r\n      guildId: this.guildId,\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Await component interactions on this message\r\n   */\r\n  awaitMessageComponent(options?: Omit<InteractionCollectorOptions, 'messageId' | 'max'>): Promise<any> {\r\n    return new Promise((resolve, reject) => {\r\n      const collector = this.createMessageComponentCollector({ ...options, max: 1 });\r\n      \r\n      collector.once('end', (collected, reason) => {\r\n        const first = collected.first();\r\n        if (first) {\r\n          resolve(first);\r\n        } else {\r\n          reject(new Error(reason || 'No interaction received'));\r\n        }\r\n      });\r\n    });\r\n  }\r\n\r\n  /**\r\n   * Convert to string\r\n   */\r\n  toString(): string {\r\n    return this.content;\r\n  }\r\n}\r\n"]}

package/dist/cjs/structures/User.d.ts

@@ -0,0 +1,37 @@
+import { APIUser } from '../types';
+/**
+ * Represents a user
+ */
+export declare class User {
+    /** User ID */
+    readonly id: string;
+    /** Username */
+    username: string;
+    /** Display name */
+    displayName?: string;
+    /** Avatar URL */
+    avatarURL?: string;
+    /** Whether this is a bot */
+    bot: boolean;
+    constructor(data: APIUser);
+    /**
+     * Get the user's tag (username)
+     */
+    get tag(): string;
+    /**
+     * Get the default avatar URL
+     */
+    get defaultAvatarURL(): string;
+    /**
+     * Get the display avatar URL
+     */
+    displayAvatarURL(): string;
+    /**
+     * Convert to string (mention format)
+     */
+    toString(): string;
+    /**
+     * Update user data
+     */
+    _patch(data: Partial<APIUser>): void;
+}

package/dist/cjs/structures/User.js

@@ -0,0 +1,65 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.User = void 0;
+/**
+ * Represents a user
+ */
+class User {
+    /** User ID */
+    id;
+    /** Username */
+    username;
+    /** Display name */
+    displayName;
+    /** Avatar URL */
+    avatarURL;
+    /** Whether this is a bot */
+    bot;
+    constructor(data) {
+        // Handle both string and number IDs (snowflake precision issue)
+        this.id = String(data.id);
+        this.username = data.username || `User_${this.id}`;
+        this.displayName = data.display_name;
+        this.avatarURL = data.avatar_url;
+        this.bot = data.bot ?? false;
+    }
+    /**
+     * Get the user's tag (username)
+     */
+    get tag() {
+        return this.username;
+    }
+    /**
+     * Get the default avatar URL
+     */
+    get defaultAvatarURL() {
+        return `https://cdn.jubbio.com/embed/avatars/${parseInt(this.id) % 5}.png`;
+    }
+    /**
+     * Get the display avatar URL
+     */
+    displayAvatarURL() {
+        return this.avatarURL || this.defaultAvatarURL;
+    }
+    /**
+     * Convert to string (mention format)
+     */
+    toString() {
+        return `<@${this.id}>`;
+    }
+    /**
+     * Update user data
+     */
+    _patch(data) {
+        if (data.username !== undefined)
+            this.username = data.username;
+        if (data.display_name !== undefined)
+            this.displayName = data.display_name;
+        if (data.avatar_url !== undefined)
+            this.avatarURL = data.avatar_url;
+        if (data.bot !== undefined)
+            this.bot = data.bot;
+    }
+}
+exports.User = User;
+//# sourceMappingURL=data:application/json;base64,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

package/dist/cjs/structures/index.d.ts

@@ -0,0 +1,7 @@
+export * from './User';
+export * from './Guild';
+export * from './Channel';
+export * from './Message';
+export * from './Interaction';
+export * from './GuildMember';
+export * from './Collection';

package/dist/cjs/structures/index.js

@@ -0,0 +1,25 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./User"), exports);
+__exportStar(require("./Guild"), exports);
+__exportStar(require("./Channel"), exports);
+__exportStar(require("./Message"), exports);
+__exportStar(require("./Interaction"), exports);
+__exportStar(require("./GuildMember"), exports);
+__exportStar(require("./Collection"), exports);
+// Collector is exported from utils
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiaW5kZXguanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvc3RydWN0dXJlcy9pbmRleC50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiOzs7Ozs7Ozs7Ozs7Ozs7O0FBQUEseUNBQXVCO0FBQ3ZCLDBDQUF3QjtBQUN4Qiw0Q0FBMEI7QUFDMUIsNENBQTBCO0FBQzFCLGdEQUE4QjtBQUM5QixnREFBOEI7QUFDOUIsK0NBQTZCO0FBQzdCLG1DQUFtQyIsInNvdXJjZXNDb250ZW50IjpbImV4cG9ydCAqIGZyb20gJy4vVXNlcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vR3VpbGQnO1xyXG5leHBvcnQgKiBmcm9tICcuL0NoYW5uZWwnO1xyXG5leHBvcnQgKiBmcm9tICcuL01lc3NhZ2UnO1xyXG5leHBvcnQgKiBmcm9tICcuL0ludGVyYWN0aW9uJztcclxuZXhwb3J0ICogZnJvbSAnLi9HdWlsZE1lbWJlcic7XHJcbmV4cG9ydCAqIGZyb20gJy4vQ29sbGVjdGlvbic7XHJcbi8vIENvbGxlY3RvciBpcyBleHBvcnRlZCBmcm9tIHV0aWxzXHJcbiJdfQ==

package/dist/cjs/structures.d.ts

@@ -0,0 +1 @@
+export * from './structures/index';

package/dist/cjs/structures.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+// Re-export all structures
+__exportStar(require("./structures/index"), exports);
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoic3RydWN0dXJlcy5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uL3NyYy9zdHJ1Y3R1cmVzLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiI7Ozs7Ozs7Ozs7Ozs7Ozs7QUFBQSwyQkFBMkI7QUFDM0IscURBQW1DIiwic291cmNlc0NvbnRlbnQiOlsiLy8gUmUtZXhwb3J0IGFsbCBzdHJ1Y3R1cmVzXHJcbmV4cG9ydCAqIGZyb20gJy4vc3RydWN0dXJlcy9pbmRleCc7XHJcbiJdfQ==

package/dist/cjs/types.d.ts

@@ -0,0 +1,255 @@
+import { GatewayIntentBits, InteractionType, ApplicationCommandType, ChannelType } from './enums';
+/**
+ * Client options
+ */
+export interface ClientOptions {
+    /** Gateway intents */
+    intents: GatewayIntentBits[] | number;
+    /** Shard configuration [shard_id, num_shards] */
+    shards?: [number, number];
+    /** Gateway URL override */
+    gatewayUrl?: string;
+    /** API URL override */
+    apiUrl?: string;
+}
+/**
+ * User structure
+ */
+export interface APIUser {
+    id: string;
+    username: string;
+    display_name?: string;
+    avatar_url?: string;
+    bot?: boolean;
+}
+/**
+ * Guild structure
+ */
+export interface APIGuild {
+    id: string;
+    name: string;
+    icon?: string;
+    owner_id: string;
+    unavailable?: boolean;
+}
+/**
+ * Channel structure
+ */
+export interface APIChannel {
+    id: string;
+    type: ChannelType;
+    guild_id?: string;
+    name?: string;
+    topic?: string;
+    position?: number;
+    parent_id?: string;
+}
+/**
+ * Message structure
+ */
+export interface APIMessage {
+    id: string;
+    channel_id: string;
+    guild_id?: string;
+    author: APIUser;
+    user_id?: number;
+    content: string | null;
+    timestamp: string;
+    edited_timestamp?: string;
+    attachments?: APIAttachment[];
+    embeds?: APIEmbed[];
+}
+/**
+ * Attachment structure
+ */
+export interface APIAttachment {
+    id: string;
+    filename: string;
+    size: number;
+    url: string;
+    proxy_url?: string;
+    content_type?: string;
+}
+/**
+ * Embed structure
+ */
+export interface APIEmbed {
+    title?: string;
+    description?: string;
+    url?: string;
+    timestamp?: string;
+    color?: number;
+    footer?: {
+        text: string;
+        icon_url?: string;
+    };
+    image?: {
+        url: string;
+    };
+    thumbnail?: {
+        url: string;
+    };
+    author?: {
+        name: string;
+        url?: string;
+        icon_url?: string;
+    };
+    fields?: {
+        name: string;
+        value: string;
+        inline?: boolean;
+    }[];
+}
+/**
+ * Interaction structure
+ */
+export interface APIInteraction {
+    id: string;
+    application_id: string;
+    type: InteractionType;
+    data?: APIInteractionData;
+    guild_id?: string;
+    channel_id?: string;
+    member?: APIGuildMember;
+    user?: APIUser;
+    token: string;
+    version: number;
+    message?: APIMessage;
+}
+/**
+ * Interaction data
+ */
+export interface APIInteractionData {
+    id?: string;
+    name?: string;
+    type?: ApplicationCommandType;
+    options?: APIInteractionOption[];
+    custom_id?: string;
+    component_type?: number;
+    values?: string[];
+    target_id?: string;
+    resolved?: APIInteractionResolved;
+}
+/**
+ * Interaction option
+ */
+export interface APIInteractionOption {
+    name: string;
+    type: number;
+    value?: string | number | boolean;
+    options?: APIInteractionOption[];
+    focused?: boolean;
+}
+/**
+ * Interaction resolved data
+ */
+export interface APIInteractionResolved {
+    users?: Record<string, APIUser>;
+    members?: Record<string, APIGuildMember>;
+    roles?: Record<string, APIRole>;
+    channels?: Record<string, APIChannel>;
+    messages?: Record<string, APIMessage>;
+    attachments?: Record<string, APIAttachment>;
+}
+/**
+ * Guild member structure
+ */
+export interface APIGuildMember {
+    user?: APIUser;
+    nick?: string;
+    avatar?: string;
+    roles: string[];
+    joined_at: string;
+    deaf?: boolean;
+    mute?: boolean;
+    permissions?: string;
+    voice?: {
+        channel_id?: string;
+        self_mute?: boolean;
+        self_deaf?: boolean;
+    };
+}
+/**
+ * Role structure
+ */
+export interface APIRole {
+    id: string;
+    name: string;
+    color: number;
+    position: number;
+    permissions: string;
+    mentionable: boolean;
+}
+/**
+ * Voice state structure
+ */
+export interface APIVoiceState {
+    guild_id?: string;
+    channel_id?: string;
+    user_id: string;
+    session_id?: string;
+    self_mute: boolean;
+    self_deaf: boolean;
+    mute?: boolean;
+    deaf?: boolean;
+}
+/**
+ * Voice server update
+ */
+export interface APIVoiceServerUpdate {
+    token: string;
+    guild_id: string;
+    endpoint: string;
+    room?: string;
+}
+/**
+ * Application command structure
+ */
+export interface APIApplicationCommand {
+    name: string;
+    description: string;
+    type?: ApplicationCommandType;
+    options?: APIApplicationCommandOption[];
+    default_permission?: boolean;
+}
+/**
+ * Application command option
+ */
+export interface APIApplicationCommandOption {
+    name: string;
+    description: string;
+    type: number;
+    required?: boolean;
+    choices?: {
+        name: string;
+        value: string | number;
+    }[];
+    options?: APIApplicationCommandOption[];
+    autocomplete?: boolean;
+    min_value?: number;
+    max_value?: number;
+    min_length?: number;
+    max_length?: number;
+}
+/**
+ * Gateway payload
+ */
+export interface GatewayPayload {
+    op: number;
+    d?: any;
+    s?: number;
+    t?: string;
+}
+/**
+ * Ready event data
+ */
+export interface ReadyEventData {
+    v: number;
+    user: APIUser;
+    guilds: APIGuild[];
+    session_id: string;
+    shard?: [number, number];
+    application: {
+        id: string;
+    };
+}

package/dist/cjs/types.js

@@ -0,0 +1,3 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi9zcmMvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IEdhdGV3YXlJbnRlbnRCaXRzLCBJbnRlcmFjdGlvblR5cGUsIEFwcGxpY2F0aW9uQ29tbWFuZFR5cGUsIENoYW5uZWxUeXBlIH0gZnJvbSAnLi9lbnVtcyc7XHJcblxyXG4vKipcclxuICogQ2xpZW50IG9wdGlvbnNcclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ2xpZW50T3B0aW9ucyB7XHJcbiAgLyoqIEdhdGV3YXkgaW50ZW50cyAqL1xyXG4gIGludGVudHM6IEdhdGV3YXlJbnRlbnRCaXRzW10gfCBudW1iZXI7XHJcbiAgLyoqIFNoYXJkIGNvbmZpZ3VyYXRpb24gW3NoYXJkX2lkLCBudW1fc2hhcmRzXSAqL1xyXG4gIHNoYXJkcz86IFtudW1iZXIsIG51bWJlcl07XHJcbiAgLyoqIEdhdGV3YXkgVVJMIG92ZXJyaWRlICovXHJcbiAgZ2F0ZXdheVVybD86IHN0cmluZztcclxuICAvKiogQVBJIFVSTCBvdmVycmlkZSAqL1xyXG4gIGFwaVVybD86IHN0cmluZztcclxufVxyXG5cclxuLyoqXHJcbiAqIFVzZXIgc3RydWN0dXJlXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEFQSVVzZXIge1xyXG4gIGlkOiBzdHJpbmc7XHJcbiAgdXNlcm5hbWU6IHN0cmluZztcclxuICBkaXNwbGF5X25hbWU/OiBzdHJpbmc7XHJcbiAgYXZhdGFyX3VybD86IHN0cmluZztcclxuICBib3Q/OiBib29sZWFuO1xyXG59XHJcblxyXG4vKipcclxuICogR3VpbGQgc3RydWN0dXJlXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEFQSUd1aWxkIHtcclxuICBpZDogc3RyaW5nO1xyXG4gIG5hbWU6IHN0cmluZztcclxuICBpY29uPzogc3RyaW5nO1xyXG4gIG93bmVyX2lkOiBzdHJpbmc7XHJcbiAgdW5hdmFpbGFibGU/OiBib29sZWFuO1xyXG59XHJcblxyXG4vKipcclxuICogQ2hhbm5lbCBzdHJ1Y3R1cmVcclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgQVBJQ2hhbm5lbCB7XHJcbiAgaWQ6IHN0cmluZztcclxuICB0eXBlOiBDaGFubmVsVHlwZTtcclxuICBndWlsZF9pZD86IHN0cmluZztcclxuICBuYW1lPzogc3RyaW5nO1xyXG4gIHRvcGljPzogc3RyaW5nO1xyXG4gIHBvc2l0aW9uPzogbnVtYmVyO1xyXG4gIHBhcmVudF9pZD86IHN0cmluZztcclxufVxyXG5cclxuLyoqXHJcbiAqIE1lc3NhZ2Ugc3RydWN0dXJlXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEFQSU1lc3NhZ2Uge1xyXG4gIGlkOiBzdHJpbmc7XHJcbiAgY2hhbm5lbF9pZDogc3RyaW5nO1xyXG4gIGd1aWxkX2lkPzogc3RyaW5nO1xyXG4gIGF1dGhvcjogQVBJVXNlcjtcclxuICB1c2VyX2lkPzogbnVtYmVyOyAvLyBCYWNrZW5kIHNlbmRzIHVzZXJfaWQgc2VwYXJhdGVseSBmcm9tIGF1dGhvclxyXG4gIGNvbnRlbnQ6IHN0cmluZyB8IG51bGw7XHJcbiAgdGltZXN0YW1wOiBzdHJpbmc7XHJcbiAgZWRpdGVkX3RpbWVzdGFtcD86IHN0cmluZztcclxuICBhdHRhY2htZW50cz86IEFQSUF0dGFjaG1lbnRbXTtcclxuICBlbWJlZHM/OiBBUElFbWJlZFtdO1xyXG59XHJcblxyXG4vKipcclxuICogQXR0YWNobWVudCBzdHJ1Y3R1cmVcclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgQVBJQXR0YWNobWVudCB7XHJcbiAgaWQ6IHN0cmluZztcclxuICBmaWxlbmFtZTogc3RyaW5nO1xyXG4gIHNpemU6IG51bWJlcjtcclxuICB1cmw6IHN0cmluZztcclxuICBwcm94eV91cmw/OiBzdHJpbmc7XHJcbiAgY29udGVudF90eXBlPzogc3RyaW5nO1xyXG59XHJcblxyXG4vKipcclxuICogRW1iZWQgc3RydWN0dXJlXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEFQSUVtYmVkIHtcclxuICB0aXRsZT86IHN0cmluZztcclxuICBkZXNjcmlwdGlvbj86IHN0cmluZztcclxuICB1cmw/OiBzdHJpbmc7XHJcbiAgdGltZXN0YW1wPzogc3RyaW5nO1xyXG4gIGNvbG9yPzogbnVtYmVyO1xyXG4gIGZvb3Rlcj86IHsgdGV4dDogc3RyaW5nOyBpY29uX3VybD86IHN0cmluZyB9O1xyXG4gIGltYWdlPzogeyB1cmw6IHN0cmluZyB9O1xyXG4gIHRodW1ibmFpbD86IHsgdXJsOiBzdHJpbmcgfTtcclxuICBhdXRob3I/OiB7IG5hbWU6IHN0cmluZzsgdXJsPzogc3RyaW5nOyBpY29uX3VybD86IHN0cmluZyB9O1xyXG4gIGZpZWxkcz86IHsgbmFtZTogc3RyaW5nOyB2YWx1ZTogc3RyaW5nOyBpbmxpbmU/OiBib29sZWFuIH1bXTtcclxufVxyXG5cclxuLyoqXHJcbiAqIEludGVyYWN0aW9uIHN0cnVjdHVyZVxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBBUElJbnRlcmFjdGlvbiB7XHJcbiAgaWQ6IHN0cmluZztcclxuICBhcHBsaWNhdGlvbl9pZDogc3RyaW5nO1xyXG4gIHR5cGU6IEludGVyYWN0aW9uVHlwZTtcclxuICBkYXRhPzogQVBJSW50ZXJhY3Rpb25EYXRhO1xyXG4gIGd1aWxkX2lkPzogc3RyaW5nO1xyXG4gIGNoYW5uZWxfaWQ/OiBzdHJpbmc7XHJcbiAgbWVtYmVyPzogQVBJR3VpbGRNZW1iZXI7XHJcbiAgdXNlcj86IEFQSVVzZXI7XHJcbiAgdG9rZW46IHN0cmluZztcclxuICB2ZXJzaW9uOiBudW1iZXI7XHJcbiAgbWVzc2FnZT86IEFQSU1lc3NhZ2U7XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBJbnRlcmFjdGlvbiBkYXRhXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEFQSUludGVyYWN0aW9uRGF0YSB7XHJcbiAgaWQ/OiBzdHJpbmc7XHJcbiAgbmFtZT86IHN0cmluZztcclxuICB0eXBlPzogQXBwbGljYXRpb25Db21tYW5kVHlwZTtcclxuICBvcHRpb25zPzogQVBJSW50ZXJhY3Rpb25PcHRpb25bXTtcclxuICBjdXN0b21faWQ/OiBzdHJpbmc7XHJcbiAgY29tcG9uZW50X3R5cGU/OiBudW1iZXI7XHJcbiAgdmFsdWVzPzogc3RyaW5nW107XHJcbiAgdGFyZ2V0X2lkPzogc3RyaW5nO1xyXG4gIHJlc29sdmVkPzogQVBJSW50ZXJhY3Rpb25SZXNvbHZlZDtcclxufVxyXG5cclxuLyoqXHJcbiAqIEludGVyYWN0aW9uIG9wdGlvblxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBBUElJbnRlcmFjdGlvbk9wdGlvbiB7XHJcbiAgbmFtZTogc3RyaW5nO1xyXG4gIHR5cGU6IG51bWJlcjtcclxuICB2YWx1ZT86IHN0cmluZyB8IG51bWJlciB8IGJvb2xlYW47XHJcbiAgb3B0aW9ucz86IEFQSUludGVyYWN0aW9uT3B0aW9uW107XHJcbiAgZm9jdXNlZD86IGJvb2xlYW47XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBJbnRlcmFjdGlvbiByZXNvbHZlZCBkYXRhXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEFQSUludGVyYWN0aW9uUmVzb2x2ZWQge1xyXG4gIHVzZXJzPzogUmVjb3JkPHN0cmluZywgQVBJVXNlcj47XHJcbiAgbWVtYmVycz86IFJlY29yZDxzdHJpbmcsIEFQSUd1aWxkTWVtYmVyPjtcclxuICByb2xlcz86IFJlY29yZDxzdHJpbmcsIEFQSVJvbGU+O1xyXG4gIGNoYW5uZWxzPzogUmVjb3JkPHN0cmluZywgQVBJQ2hhbm5lbD47XHJcbiAgbWVzc2FnZXM/OiBSZWNvcmQ8c3RyaW5nLCBBUElNZXNzYWdlPjtcclxuICBhdHRhY2htZW50cz86IFJlY29yZDxzdHJpbmcsIEFQSUF0dGFjaG1lbnQ+O1xyXG59XHJcblxyXG4vKipcclxuICogR3VpbGQgbWVtYmVyIHN0cnVjdHVyZVxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBBUElHdWlsZE1lbWJlciB7XHJcbiAgdXNlcj86IEFQSVVzZXI7XHJcbiAgbmljaz86IHN0cmluZztcclxuICBhdmF0YXI/OiBzdHJpbmc7XHJcbiAgcm9sZXM6IHN0cmluZ1tdO1xyXG4gIGpvaW5lZF9hdDogc3RyaW5nO1xyXG4gIGRlYWY/OiBib29sZWFuO1xyXG4gIG11dGU/OiBib29sZWFuO1xyXG4gIHBlcm1pc3Npb25zPzogc3RyaW5nO1xyXG4gIHZvaWNlPzoge1xyXG4gICAgY2hhbm5lbF9pZD86IHN0cmluZztcclxuICAgIHNlbGZfbXV0ZT86IGJvb2xlYW47XHJcbiAgICBzZWxmX2RlYWY/OiBib29sZWFuO1xyXG4gIH07XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBSb2xlIHN0cnVjdHVyZVxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBBUElSb2xlIHtcclxuICBpZDogc3RyaW5nO1xyXG4gIG5hbWU6IHN0cmluZztcclxuICBjb2xvcjogbnVtYmVyO1xyXG4gIHBvc2l0aW9uOiBudW1iZXI7XHJcbiAgcGVybWlzc2lvbnM6IHN0cmluZztcclxuICBtZW50aW9uYWJsZTogYm9vbGVhbjtcclxufVxyXG5cclxuLyoqXHJcbiAqIFZvaWNlIHN0YXRlIHN0cnVjdHVyZVxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBBUElWb2ljZVN0YXRlIHtcclxuICBndWlsZF9pZD86IHN0cmluZztcclxuICBjaGFubmVsX2lkPzogc3RyaW5nO1xyXG4gIHVzZXJfaWQ6IHN0cmluZztcclxuICBzZXNzaW9uX2lkPzogc3RyaW5nO1xyXG4gIHNlbGZfbXV0ZTogYm9vbGVhbjtcclxuICBzZWxmX2RlYWY6IGJvb2xlYW47XHJcbiAgbXV0ZT86IGJvb2xlYW47XHJcbiAgZGVhZj86IGJvb2xlYW47XHJcbn1cclxuXHJcbi8qKlxyXG4gKiBWb2ljZSBzZXJ2ZXIgdXBkYXRlXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEFQSVZvaWNlU2VydmVyVXBkYXRlIHtcclxuICB0b2tlbjogc3RyaW5nO1xyXG4gIGd1aWxkX2lkOiBzdHJpbmc7XHJcbiAgZW5kcG9pbnQ6IHN0cmluZztcclxuICByb29tPzogc3RyaW5nO1xyXG59XHJcblxyXG4vKipcclxuICogQXBwbGljYXRpb24gY29tbWFuZCBzdHJ1Y3R1cmVcclxuICovXHJcbmV4cG9ydCBpbnRlcmZhY2UgQVBJQXBwbGljYXRpb25Db21tYW5kIHtcclxuICBuYW1lOiBzdHJpbmc7XHJcbiAgZGVzY3JpcHRpb246IHN0cmluZztcclxuICB0eXBlPzogQXBwbGljYXRpb25Db21tYW5kVHlwZTtcclxuICBvcHRpb25zPzogQVBJQXBwbGljYXRpb25Db21tYW5kT3B0aW9uW107XHJcbiAgZGVmYXVsdF9wZXJtaXNzaW9uPzogYm9vbGVhbjtcclxufVxyXG5cclxuLyoqXHJcbiAqIEFwcGxpY2F0aW9uIGNvbW1hbmQgb3B0aW9uXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEFQSUFwcGxpY2F0aW9uQ29tbWFuZE9wdGlvbiB7XHJcbiAgbmFtZTogc3RyaW5nO1xyXG4gIGRlc2NyaXB0aW9uOiBzdHJpbmc7XHJcbiAgdHlwZTogbnVtYmVyO1xyXG4gIHJlcXVpcmVkPzogYm9vbGVhbjtcclxuICBjaG9pY2VzPzogeyBuYW1lOiBzdHJpbmc7IHZhbHVlOiBzdHJpbmcgfCBudW1iZXIgfVtdO1xyXG4gIG9wdGlvbnM/OiBBUElBcHBsaWNhdGlvbkNvbW1hbmRPcHRpb25bXTtcclxuICBhdXRvY29tcGxldGU/OiBib29sZWFuO1xyXG4gIG1pbl92YWx1ZT86IG51bWJlcjtcclxuICBtYXhfdmFsdWU/OiBudW1iZXI7XHJcbiAgbWluX2xlbmd0aD86IG51bWJlcjtcclxuICBtYXhfbGVuZ3RoPzogbnVtYmVyO1xyXG59XHJcblxyXG4vKipcclxuICogR2F0ZXdheSBwYXlsb2FkXHJcbiAqL1xyXG5leHBvcnQgaW50ZXJmYWNlIEdhdGV3YXlQYXlsb2FkIHtcclxuICBvcDogbnVtYmVyO1xyXG4gIGQ/OiBhbnk7XHJcbiAgcz86IG51bWJlcjtcclxuICB0Pzogc3RyaW5nO1xyXG59XHJcblxyXG4vKipcclxuICogUmVhZHkgZXZlbnQgZGF0YVxyXG4gKi9cclxuZXhwb3J0IGludGVyZmFjZSBSZWFkeUV2ZW50RGF0YSB7XHJcbiAgdjogbnVtYmVyO1xyXG4gIHVzZXI6IEFQSVVzZXI7XHJcbiAgZ3VpbGRzOiBBUElHdWlsZFtdO1xyXG4gIHNlc3Npb25faWQ6IHN0cmluZztcclxuICBzaGFyZD86IFtudW1iZXIsIG51bWJlcl07XHJcbiAgYXBwbGljYXRpb246IHsgaWQ6IHN0cmluZyB9O1xyXG59XHJcbiJdfQ==