privage.js 0.21.0

package/dist/attachments.d.ts

@@ -0,0 +1,41 @@
+/** A file source for message attachments: a filesystem path, raw bytes, or a Blob. */
+export type AttachmentSource = string | Buffer | Uint8Array | Blob;
+/**
+ * Fluent attachment wrapper (discord.js-style). Wraps a file source with the
+ * filename (and optional content type) it should carry in the upload.
+ *
+ * Attachments upload as multipart; the server allows up to 10 per message
+ * (25 MB each by default) and blocks executable file types. Note the v1
+ * limitation: a message can carry attachments OR embeds, not both.
+ */
+export declare class AttachmentBuilder {
+    private readonly source;
+    private name?;
+    private contentType?;
+    private spoilerFlag?;
+    constructor(source: AttachmentSource, options?: {
+        name?: string;
+        contentType?: string;
+        spoiler?: boolean;
+    });
+    /** Filename shown in the client (defaults to the path's basename, or 'file'). */
+    setName(name: string): this;
+    /** Explicit MIME type for the upload part. */
+    setContentType(contentType: string): this;
+    /** Mark the attachment as a spoiler — blurred in the client until revealed. */
+    setSpoiler(spoiler?: boolean): this;
+    /** Whether this attachment uploads as a spoiler (per-file flag; filenames are never involved). */
+    get spoiler(): boolean;
+    /** Resolve to the `{ blob, name, spoiler }` triple appended to the multipart body. */
+    resolve(): Promise<{
+        blob: Blob;
+        name: string;
+        spoiler: boolean;
+    }>;
+}
+/** Normalize a `files` array (builders or raw sources) to upload parts. */
+export declare function resolveFiles(files: (AttachmentBuilder | AttachmentSource)[]): Promise<{
+    blob: Blob;
+    name: string;
+    spoiler: boolean;
+}[]>;

package/dist/attachments.js

@@ -0,0 +1,63 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AttachmentBuilder = void 0;
+exports.resolveFiles = resolveFiles;
+const promises_1 = require("fs/promises");
+const path_1 = require("path");
+/**
+ * Fluent attachment wrapper (discord.js-style). Wraps a file source with the
+ * filename (and optional content type) it should carry in the upload.
+ *
+ * Attachments upload as multipart; the server allows up to 10 per message
+ * (25 MB each by default) and blocks executable file types. Note the v1
+ * limitation: a message can carry attachments OR embeds, not both.
+ */
+class AttachmentBuilder {
+    constructor(source, options = {}) {
+        this.source = source;
+        this.name = options.name;
+        this.contentType = options.contentType;
+        this.spoilerFlag = options.spoiler;
+    }
+    /** Filename shown in the client (defaults to the path's basename, or 'file'). */
+    setName(name) {
+        this.name = name;
+        return this;
+    }
+    /** Explicit MIME type for the upload part. */
+    setContentType(contentType) {
+        this.contentType = contentType;
+        return this;
+    }
+    /** Mark the attachment as a spoiler — blurred in the client until revealed. */
+    setSpoiler(spoiler = true) {
+        this.spoilerFlag = spoiler;
+        return this;
+    }
+    /** Whether this attachment uploads as a spoiler (per-file flag; filenames are never involved). */
+    get spoiler() {
+        return this.spoilerFlag ?? false;
+    }
+    /** Resolve to the `{ blob, name, spoiler }` triple appended to the multipart body. */
+    async resolve() {
+        const name = this.name ?? (typeof this.source === 'string' ? (0, path_1.basename)(this.source) : 'file');
+        const spoiler = this.spoiler;
+        if (this.source instanceof Blob) {
+            const blob = this.contentType
+                ? new Blob([await this.source.arrayBuffer()], { type: this.contentType })
+                : this.source;
+            return { blob, name, spoiler };
+        }
+        const bytes = typeof this.source === 'string' ? await (0, promises_1.readFile)(this.source) : this.source;
+        return {
+            blob: new Blob([bytes], this.contentType ? { type: this.contentType } : undefined),
+            name,
+            spoiler,
+        };
+    }
+}
+exports.AttachmentBuilder = AttachmentBuilder;
+/** Normalize a `files` array (builders or raw sources) to upload parts. */
+function resolveFiles(files) {
+    return Promise.all(files.map((f) => (f instanceof AttachmentBuilder ? f : new AttachmentBuilder(f)).resolve()));
+}

package/dist/collectors.d.ts

@@ -0,0 +1,41 @@
+import { EventEmitter } from 'events';
+import type { Message } from './structures/Message';
+import type { Client } from './Client';
+export interface MessageCollectorOptions {
+    /** Only collect messages from this channel. */
+    channelId?: string;
+    /** Predicate a message must pass to be collected. */
+    filter?: (message: Message) => boolean;
+    /** Stop after collecting this many messages. */
+    max?: number;
+    /** Stop after this long (default 60_000 ms). */
+    timeMs?: number;
+}
+export type CollectorEndReason = 'limit' | 'time' | 'user';
+export interface MessageCollector {
+    on(event: 'collect', listener: (message: Message) => void): this;
+    on(event: 'end', listener: (collected: Message[], reason: CollectorEndReason) => void): this;
+    once(event: 'collect', listener: (message: Message) => void): this;
+    once(event: 'end', listener: (collected: Message[], reason: CollectorEndReason) => void): this;
+}
+/**
+ * Collects `messageCreate` events matching a filter until a count or time
+ * limit — the standard building block for confirmations and wizards.
+ * Unsubscribes from the client automatically on end.
+ */
+export declare class MessageCollector extends EventEmitter {
+    private readonly client;
+    private readonly options;
+    readonly collected: Message[];
+    private ended;
+    private readonly timer;
+    private readonly listener;
+    constructor(client: Client, options?: MessageCollectorOptions);
+    /** End the collector; emits `end` with everything collected and the reason. */
+    stop(reason?: CollectorEndReason): void;
+}
+/**
+ * Promise form: resolves with the collected messages once `max` is reached
+ * or time runs out (resolves with whatever was collected — check `.length`).
+ */
+export declare function awaitMessages(client: Client, options?: MessageCollectorOptions): Promise<Message[]>;

package/dist/collectors.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MessageCollector = void 0;
+exports.awaitMessages = awaitMessages;
+const events_1 = require("events");
+/**
+ * Collects `messageCreate` events matching a filter until a count or time
+ * limit — the standard building block for confirmations and wizards.
+ * Unsubscribes from the client automatically on end.
+ */
+class MessageCollector extends events_1.EventEmitter {
+    constructor(client, options = {}) {
+        super();
+        this.client = client;
+        this.options = options;
+        this.collected = [];
+        this.ended = false;
+        this.listener = (message) => {
+            if (this.options.channelId && message.channelId !== this.options.channelId)
+                return;
+            if (this.options.filter && !this.options.filter(message))
+                return;
+            this.collected.push(message);
+            this.emit('collect', message);
+            if (this.options.max && this.collected.length >= this.options.max)
+                this.stop('limit');
+        };
+        client.on('messageCreate', this.listener);
+        this.timer = setTimeout(() => this.stop('time'), this.options.timeMs ?? 60000);
+        this.timer.unref?.();
+    }
+    /** End the collector; emits `end` with everything collected and the reason. */
+    stop(reason = 'user') {
+        if (this.ended)
+            return;
+        this.ended = true;
+        clearTimeout(this.timer);
+        this.client.off('messageCreate', this.listener);
+        this.emit('end', this.collected, reason);
+    }
+}
+exports.MessageCollector = MessageCollector;
+/**
+ * Promise form: resolves with the collected messages once `max` is reached
+ * or time runs out (resolves with whatever was collected — check `.length`).
+ */
+function awaitMessages(client, options = {}) {
+    return new Promise((resolve) => {
+        const collector = new MessageCollector(client, { max: 1, ...options });
+        collector.on('end', (collected) => resolve(collected));
+    });
+}

package/dist/commands.d.ts

@@ -0,0 +1,108 @@
+/**
+ * Slash-command registry (interactions v2 §3). A bot manages ONLY its own
+ * commands — `client.commands.set([...])` bulk-overwrites the whole set
+ * (whole-or-400 server-side; the same grammar is validated here first so
+ * mistakes fail loud and local), `client.commands.fetch()` lists it.
+ *
+ * Invocations arrive as `interaction` events with `kind: 'command'` —
+ * see `interaction.command` / `interaction.command.getOption(name)`.
+ */
+import type { Client } from './Client';
+import type { CommandOptionType } from './structures/Interaction';
+/** Server-enforced registry limits (mirrored client-side). */
+export declare const CommandLimits: {
+    /** Commands per bot (one `set()` payload). */
+    readonly Commands: 50;
+    /** `^[a-z0-9_-]{1,32}$` for command and option names. */
+    readonly NamePattern: RegExp;
+    readonly Description: 100;
+    readonly Options: 10;
+    readonly Choices: 25;
+    readonly ChoiceName: 100;
+    readonly ChoiceStringValue: 100;
+};
+/** A pre-baked choice for a string/integer/number option. */
+export interface CommandChoice {
+    /** ≤100 chars — what the invoker sees. */
+    name: string;
+    /** Must match the option type: string (≤100 chars) or number. */
+    value: string | number;
+}
+export interface CommandOptionData {
+    type: CommandOptionType;
+    /** `^[a-z0-9_-]{1,32}$`, unique within the command. */
+    name: string;
+    /** Required, ≤100 chars. */
+    description: string;
+    /** Required options must precede optional ones. Server default: false. */
+    required?: boolean;
+    /** string/integer/number options only, 1–25. */
+    choices?: CommandChoice[];
+}
+export interface BotCommandData {
+    /** `^[a-z0-9_-]{1,32}$`, unique per bot. */
+    name: string;
+    /** Required, ≤100 chars. */
+    description: string;
+    /** ≤10 options. */
+    options?: CommandOptionData[];
+}
+/** A registered command, as the server returns it. */
+export interface BotCommand extends BotCommandData {
+    id: string;
+    options: CommandOptionData[];
+}
+/** Mirror of the server's registry grammar (whole-or-400) — throws RangeError with the field path. */
+export declare function validateCommands(commands: BotCommandData[]): void;
+/** Option builder used by {@link SlashCommandBuilder} — mirrors discord.js's shape. */
+export declare class SlashCommandOptionBuilder {
+    private readonly data;
+    constructor(type: CommandOptionType);
+    /** `^[a-z0-9_-]{1,32}$`, unique within the command. */
+    setName(name: string): this;
+    /** Required, ≤100 chars. */
+    setDescription(description: string): this;
+    /** Required options must precede optional ones. */
+    setRequired(required?: boolean): this;
+    /** string/integer/number options only (1–25 choices). */
+    addChoices(...choices: CommandChoice[]): this;
+    toJSON(): CommandOptionData;
+}
+type OptionInput = SlashCommandOptionBuilder | ((option: SlashCommandOptionBuilder) => SlashCommandOptionBuilder);
+/**
+ * discord.js-style command builder — `new SlashCommandBuilder().setName(...)
+ * .addStringOption(o => o.setName(...))` ports verbatim and emits plain
+ * {@link BotCommandData}. Full validation happens in `client.commands.set()`
+ * (same grammar as the server, thrown as `RangeError` with the field path).
+ */
+export declare class SlashCommandBuilder {
+    private readonly data;
+    private readonly options;
+    /** `^[a-z0-9_-]{1,32}$`, unique per bot. */
+    setName(name: string): this;
+    /** Required, ≤100 chars. */
+    setDescription(description: string): this;
+    private addOption;
+    addStringOption(input: OptionInput): this;
+    addIntegerOption(input: OptionInput): this;
+    addNumberOption(input: OptionInput): this;
+    addBooleanOption(input: OptionInput): this;
+    addUserOption(input: OptionInput): this;
+    addChannelOption(input: OptionInput): this;
+    addRoleOption(input: OptionInput): this;
+    toJSON(): BotCommandData;
+}
+/** `client.commands` — the bot's slash-command registry. Available after `login()`. */
+export declare class CommandsManager {
+    private readonly client;
+    constructor(client: Client);
+    /**
+     * Bulk-overwrite the bot's whole command set (≤50; `[]` clears it).
+     * Validated client-side against the registry grammar before the request —
+     * throws RangeError on the first violation. Rate limit: 5/60s.
+     */
+    set(commands: (BotCommandData | SlashCommandBuilder)[]): Promise<BotCommand[]>;
+    /** List the bot's registered commands. */
+    fetch(): Promise<BotCommand[]>;
+}
+export {};

package/dist/commands.js

@@ -0,0 +1,216 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CommandsManager = exports.SlashCommandBuilder = exports.SlashCommandOptionBuilder = exports.CommandLimits = void 0;
+exports.validateCommands = validateCommands;
+/** Server-enforced registry limits (mirrored client-side). */
+exports.CommandLimits = {
+    /** Commands per bot (one `set()` payload). */
+    Commands: 50,
+    /** `^[a-z0-9_-]{1,32}$` for command and option names. */
+    NamePattern: /^[a-z0-9_-]{1,32}$/,
+    Description: 100,
+    Options: 10,
+    Choices: 25,
+    ChoiceName: 100,
+    ChoiceStringValue: 100,
+};
+const OPTION_TYPES = new Set(['string', 'integer', 'number', 'boolean', 'user', 'channel', 'role']);
+const CHOICE_TYPES = new Set(['string', 'integer', 'number']);
+function fail(message) {
+    throw new RangeError(message);
+}
+/** Mirror of the server's registry grammar (whole-or-400) — throws RangeError with the field path. */
+function validateCommands(commands) {
+    if (!Array.isArray(commands))
+        fail('commands must be an array.');
+    if (commands.length > exports.CommandLimits.Commands) {
+        fail(`At most ${exports.CommandLimits.Commands} commands per bot (got ${commands.length}).`);
+    }
+    const seenNames = new Set();
+    commands.forEach((command, cmdIdx) => {
+        const path = `commands[${cmdIdx}]`;
+        if (!command || typeof command !== 'object')
+            fail(`${path} must be a command object.`);
+        if (typeof command.name !== 'string' || !exports.CommandLimits.NamePattern.test(command.name)) {
+            fail(`${path}.name must match ^[a-z0-9_-]{1,32}$.`);
+        }
+        if (seenNames.has(command.name))
+            fail(`${path}.name "${command.name}" is duplicated — command names must be unique per bot.`);
+        seenNames.add(command.name);
+        if (typeof command.description !== 'string' || command.description.length === 0 || command.description.length > exports.CommandLimits.Description) {
+            fail(`${path}.description is required (≤${exports.CommandLimits.Description} characters).`);
+        }
+        if (command.options === undefined)
+            return;
+        if (!Array.isArray(command.options) || command.options.length > exports.CommandLimits.Options) {
+            fail(`${path}.options must be an array of at most ${exports.CommandLimits.Options} options.`);
+        }
+        const seenOptions = new Set();
+        let sawOptional = false;
+        command.options.forEach((option, optIdx) => {
+            const optPath = `${path}.options[${optIdx}]`;
+            if (!option || typeof option !== 'object')
+                fail(`${optPath} must be an option object.`);
+            if (typeof option.type !== 'string' || !OPTION_TYPES.has(option.type)) {
+                fail(`${optPath}.type must be one of: string, integer, number, boolean, user, channel, role.`);
+            }
+            if (typeof option.name !== 'string' || !exports.CommandLimits.NamePattern.test(option.name)) {
+                fail(`${optPath}.name must match ^[a-z0-9_-]{1,32}$.`);
+            }
+            if (seenOptions.has(option.name))
+                fail(`${optPath}.name "${option.name}" is duplicated within the command.`);
+            seenOptions.add(option.name);
+            if (typeof option.description !== 'string' || option.description.length === 0 || option.description.length > exports.CommandLimits.Description) {
+                fail(`${optPath}.description is required (≤${exports.CommandLimits.Description} characters).`);
+            }
+            if (option.required !== true) {
+                sawOptional = true;
+            }
+            else if (sawOptional) {
+                fail(`${path}.options: required options must precede optional ones.`);
+            }
+            if (option.choices === undefined)
+                return;
+            if (!CHOICE_TYPES.has(option.type))
+                fail(`${optPath}.choices are only allowed for string, integer, and number options.`);
+            if (!Array.isArray(option.choices) || option.choices.length === 0 || option.choices.length > exports.CommandLimits.Choices) {
+                fail(`${optPath}.choices must be an array of 1 to ${exports.CommandLimits.Choices} choices.`);
+            }
+            const seenChoiceNames = new Set();
+            option.choices.forEach((choice, choiceIdx) => {
+                const choicePath = `${optPath}.choices[${choiceIdx}]`;
+                if (!choice || typeof choice !== 'object')
+                    fail(`${choicePath} must be a choice object.`);
+                if (typeof choice.name !== 'string' || choice.name.length === 0 || choice.name.length > exports.CommandLimits.ChoiceName) {
+                    fail(`${choicePath}.name is required (≤${exports.CommandLimits.ChoiceName} characters).`);
+                }
+                if (seenChoiceNames.has(choice.name))
+                    fail(`${choicePath}.name "${choice.name}" is duplicated within the option.`);
+                seenChoiceNames.add(choice.name);
+                if (option.type === 'string') {
+                    if (typeof choice.value !== 'string' || choice.value.length === 0 || choice.value.length > exports.CommandLimits.ChoiceStringValue) {
+                        fail(`${choicePath}.value must be a string of at most ${exports.CommandLimits.ChoiceStringValue} characters for string options.`);
+                    }
+                }
+                else if (option.type === 'integer') {
+                    if (typeof choice.value !== 'number' || !Number.isSafeInteger(choice.value)) {
+                        fail(`${choicePath}.value must be an integer for integer options.`);
+                    }
+                }
+                else if (typeof choice.value !== 'number' || !Number.isFinite(choice.value)) {
+                    fail(`${choicePath}.value must be a number for number options.`);
+                }
+            });
+        });
+    });
+}
+/** Option builder used by {@link SlashCommandBuilder} — mirrors discord.js's shape. */
+class SlashCommandOptionBuilder {
+    constructor(type) {
+        this.data = { type };
+    }
+    /** `^[a-z0-9_-]{1,32}$`, unique within the command. */
+    setName(name) {
+        this.data.name = name;
+        return this;
+    }
+    /** Required, ≤100 chars. */
+    setDescription(description) {
+        this.data.description = description;
+        return this;
+    }
+    /** Required options must precede optional ones. */
+    setRequired(required = true) {
+        this.data.required = required;
+        return this;
+    }
+    /** string/integer/number options only (1–25 choices). */
+    addChoices(...choices) {
+        this.data.choices = [...(this.data.choices ?? []), ...choices];
+        return this;
+    }
+    toJSON() {
+        return { ...this.data };
+    }
+}
+exports.SlashCommandOptionBuilder = SlashCommandOptionBuilder;
+/**
+ * discord.js-style command builder — `new SlashCommandBuilder().setName(...)
+ * .addStringOption(o => o.setName(...))` ports verbatim and emits plain
+ * {@link BotCommandData}. Full validation happens in `client.commands.set()`
+ * (same grammar as the server, thrown as `RangeError` with the field path).
+ */
+class SlashCommandBuilder {
+    constructor() {
+        this.data = {};
+        this.options = [];
+    }
+    /** `^[a-z0-9_-]{1,32}$`, unique per bot. */
+    setName(name) {
+        this.data.name = name;
+        return this;
+    }
+    /** Required, ≤100 chars. */
+    setDescription(description) {
+        this.data.description = description;
+        return this;
+    }
+    addOption(type, input) {
+        const builder = input instanceof SlashCommandOptionBuilder ? input : input(new SlashCommandOptionBuilder(type));
+        const option = builder.toJSON();
+        this.options.push({ ...option, type });
+        return this;
+    }
+    addStringOption(input) {
+        return this.addOption('string', input);
+    }
+    addIntegerOption(input) {
+        return this.addOption('integer', input);
+    }
+    addNumberOption(input) {
+        return this.addOption('number', input);
+    }
+    addBooleanOption(input) {
+        return this.addOption('boolean', input);
+    }
+    addUserOption(input) {
+        return this.addOption('user', input);
+    }
+    addChannelOption(input) {
+        return this.addOption('channel', input);
+    }
+    addRoleOption(input) {
+        return this.addOption('role', input);
+    }
+    toJSON() {
+        return {
+            name: this.data.name,
+            description: this.data.description,
+            ...(this.options.length ? { options: this.options.map((o) => ({ ...o })) } : {}),
+        };
+    }
+}
+exports.SlashCommandBuilder = SlashCommandBuilder;
+/** `client.commands` — the bot's slash-command registry. Available after `login()`. */
+class CommandsManager {
+    constructor(client) {
+        this.client = client;
+    }
+    /**
+     * Bulk-overwrite the bot's whole command set (≤50; `[]` clears it).
+     * Validated client-side against the registry grammar before the request —
+     * throws RangeError on the first violation. Rate limit: 5/60s.
+     */
+    async set(commands) {
+        const resolved = commands.map((c) => (c instanceof SlashCommandBuilder ? c.toJSON() : c));
+        validateCommands(resolved);
+        const res = await this.client.rest.setCommands(resolved);
+        return res?.commands ?? [];
+    }
+    /** List the bot's registered commands. */
+    async fetch() {
+        const res = await this.client.rest.fetchCommands();
+        return res?.commands ?? [];
+    }
+}
+exports.CommandsManager = CommandsManager;

package/dist/compat.d.ts

@@ -0,0 +1,72 @@
+/**
+ * discord.js event-name constants mapped to this SDK's events.
+ * `client.on(Events.MessageCreate, ...)` ports verbatim.
+ */
+export declare const Events: {
+    readonly ClientReady: "ready";
+    readonly MessageCreate: "messageCreate";
+    readonly MessageUpdate: "messageUpdate";
+    readonly MessageDelete: "messageDelete";
+    readonly MessageBulkDelete: "messageDeleteBulk";
+    readonly MessageReactionAdd: "reactionAdd";
+    readonly MessageReactionRemove: "reactionRemove";
+    readonly InteractionCreate: "interaction";
+    readonly GuildMemberAdd: "memberJoin";
+    readonly GuildMemberRemove: "memberLeave";
+    readonly GuildMemberUpdate: "memberUpdate";
+    readonly GuildBanAdd: "memberBan";
+    readonly GuildBanRemove: "memberUnban";
+    readonly ChannelCreate: "channelCreate";
+    readonly ChannelUpdate: "channelUpdate";
+    readonly ChannelDelete: "channelDelete";
+    readonly GuildRoleCreate: "roleCreate";
+    readonly GuildRoleUpdate: "roleUpdate";
+    readonly GuildRoleDelete: "roleDelete";
+    readonly TypingStart: "typingStart";
+    /** Recoverable transport failures — the SDK reconnects on its own. */
+    readonly Error: "connectionError";
+    readonly Warn: "warn";
+    readonly Debug: "debug";
+};
+/** The discord.js named color palette (same values), plus Privage brand colors. */
+export declare const Colors: {
+    readonly Default: 0;
+    readonly White: 16777215;
+    readonly Aqua: 1752220;
+    readonly Green: 5763719;
+    readonly Blue: 3447003;
+    readonly Yellow: 16705372;
+    readonly Purple: 10181046;
+    readonly LuminousVividPink: 15277667;
+    readonly Fuchsia: 15418782;
+    readonly Gold: 15844367;
+    readonly Orange: 15105570;
+    readonly Red: 15548997;
+    readonly Grey: 9807270;
+    readonly Navy: 3426654;
+    readonly DarkAqua: 1146986;
+    readonly DarkGreen: 2067276;
+    readonly DarkBlue: 2123412;
+    readonly DarkPurple: 7419530;
+    readonly DarkVividPink: 11342935;
+    readonly DarkGold: 12745742;
+    readonly DarkOrange: 11027200;
+    readonly DarkRed: 10038562;
+    readonly DarkGrey: 9936031;
+    readonly DarkerGrey: 8359053;
+    readonly LightGrey: 12370112;
+    readonly DarkNavy: 2899536;
+    /**
+     * Alias of {@link Colors.Privage} — NOT Discord's blurple. Ported bots
+     * that `setColor(Colors.Blurple)` land on Privage's brand purple
+     * automatically (and we don't ship a competitor's brand color).
+     */
+    readonly Blurple: 6056644;
+    readonly Greyple: 10070709;
+    readonly DarkButNotBlack: 2895667;
+    readonly NotQuiteBlack: 2303786;
+    /** Privage's primary indigo. */
+    readonly Privage: 6056644;
+    /** Privage's cyan accent. */
+    readonly PrivageAccent: 2282478;
+};

package/dist/compat.js

@@ -0,0 +1,75 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Colors = exports.Events = void 0;
+/**
+ * discord.js event-name constants mapped to this SDK's events.
+ * `client.on(Events.MessageCreate, ...)` ports verbatim.
+ */
+exports.Events = {
+    ClientReady: 'ready',
+    MessageCreate: 'messageCreate',
+    MessageUpdate: 'messageUpdate',
+    MessageDelete: 'messageDelete',
+    MessageBulkDelete: 'messageDeleteBulk',
+    MessageReactionAdd: 'reactionAdd',
+    MessageReactionRemove: 'reactionRemove',
+    InteractionCreate: 'interaction',
+    GuildMemberAdd: 'memberJoin',
+    GuildMemberRemove: 'memberLeave',
+    GuildMemberUpdate: 'memberUpdate',
+    GuildBanAdd: 'memberBan',
+    GuildBanRemove: 'memberUnban',
+    ChannelCreate: 'channelCreate',
+    ChannelUpdate: 'channelUpdate',
+    ChannelDelete: 'channelDelete',
+    GuildRoleCreate: 'roleCreate',
+    GuildRoleUpdate: 'roleUpdate',
+    GuildRoleDelete: 'roleDelete',
+    TypingStart: 'typingStart',
+    /** Recoverable transport failures — the SDK reconnects on its own. */
+    Error: 'connectionError',
+    Warn: 'warn',
+    Debug: 'debug',
+};
+/** The discord.js named color palette (same values), plus Privage brand colors. */
+exports.Colors = {
+    Default: 0x000000,
+    White: 0xffffff,
+    Aqua: 0x1abc9c,
+    Green: 0x57f287,
+    Blue: 0x3498db,
+    Yellow: 0xfee75c,
+    Purple: 0x9b59b6,
+    LuminousVividPink: 0xe91e63,
+    Fuchsia: 0xeb459e,
+    Gold: 0xf1c40f,
+    Orange: 0xe67e22,
+    Red: 0xed4245,
+    Grey: 0x95a5a6,
+    Navy: 0x34495e,
+    DarkAqua: 0x11806a,
+    DarkGreen: 0x1f8b4c,
+    DarkBlue: 0x206694,
+    DarkPurple: 0x71368a,
+    DarkVividPink: 0xad1457,
+    DarkGold: 0xc27c0e,
+    DarkOrange: 0xa84300,
+    DarkRed: 0x992d22,
+    DarkGrey: 0x979c9f,
+    DarkerGrey: 0x7f8c8d,
+    LightGrey: 0xbcc0c0,
+    DarkNavy: 0x2c3e50,
+    /**
+     * Alias of {@link Colors.Privage} — NOT Discord's blurple. Ported bots
+     * that `setColor(Colors.Blurple)` land on Privage's brand purple
+     * automatically (and we don't ship a competitor's brand color).
+     */
+    Blurple: 0x5c6ac4,
+    Greyple: 0x99aab5,
+    DarkButNotBlack: 0x2c2f33,
+    NotQuiteBlack: 0x23272a,
+    /** Privage's primary indigo. */
+    Privage: 0x5c6ac4,
+    /** Privage's cyan accent. */
+    PrivageAccent: 0x22d3ee,
+};