@dereekb/nestjs 13.1.0 → 13.2.1

package/discord/index.esm.js

@@ -0,0 +1,475 @@
+import { handlerFactory, handlerConfigurerFactory, handlerMappedSetFunctionFactory, lastValue } from '@dereekb/util';
+import { InteractionType, GatewayIntentBits, Client, TextChannel, Events } from 'discord.js';
+import { RawBody } from '@dereekb/nestjs';
+import { Injectable, Inject, Logger, Post, Req, Controller, Module } from '@nestjs/common';
+import { createPublicKey, verify } from 'crypto';
+import { ConfigService, ConfigModule } from '@nestjs/config';
+import { fetchPageFactory } from '@dereekb/util/fetch';
+
+/**
+ * Casts an untyped Discord interaction to a typed one.
+ *
+ * @param interaction - the raw interaction to cast
+ */
+function discordWebhookInteraction(interaction) {
+    return interaction;
+}
+const discordInteractionHandlerFactory = handlerFactory((x) => x.type);
+const discordInteractionHandlerConfigurerFactory = handlerConfigurerFactory({
+    configurerForAccessor: (accessor) => {
+        // eslint-disable-next-line
+        const fnWithKey = handlerMappedSetFunctionFactory(accessor, discordWebhookInteraction);
+        const configurer = {
+            ...accessor,
+            handleApplicationCommand: fnWithKey(InteractionType.ApplicationCommand),
+            handleMessageComponent: fnWithKey(InteractionType.MessageComponent),
+            handleModalSubmit: fnWithKey(InteractionType.ModalSubmit),
+            handleAutocomplete: fnWithKey(InteractionType.ApplicationCommandAutocomplete)
+        };
+        return configurer;
+    }
+});
+
+/**
+ * Default environment variable for the Discord application public key.
+ */
+const DISCORD_PUBLIC_KEY_ENV_VAR = 'DISCORD_PUBLIC_KEY';
+/**
+ * Configuration for the DiscordWebhookService.
+ */
+class DiscordWebhookServiceConfig {
+    discordWebhook;
+    static assertValidConfig(config) {
+        if (!config.discordWebhook.publicKey) {
+            throw new Error('No Discord public key specified.');
+        }
+    }
+}
+
+/******************************************************************************
+Copyright (c) Microsoft Corporation.
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.
+***************************************************************************** */
+/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
+
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+};
+
+/**
+ * Creates a verifier for Discord interaction webhook requests.
+ *
+ * Discord signs interaction webhook requests with Ed25519. The signed message is
+ * the concatenation of the x-signature-timestamp header and the raw request body.
+ * The signature is provided in the x-signature-ed25519 header as a hex string.
+ *
+ * Uses Node.js built-in crypto with JWK key import — no external dependencies required.
+ *
+ * @param config - verification config containing the application's public key
+ *
+ * @example
+ * ```ts
+ * const verifier = discordWebhookEventVerifier({ publicKey: 'your-hex-public-key' });
+ * const result = await verifier(req, rawBody);
+ *
+ * if (result.valid) {
+ *   // result.body contains the parsed interaction
+ * }
+ * ```
+ */
+function discordWebhookEventVerifier(config) {
+    const { publicKey: publicKeyHex } = config;
+    // Import the raw 32-byte Ed25519 public key via JWK format.
+    const publicKey = createPublicKey({
+        key: {
+            kty: 'OKP',
+            crv: 'Ed25519',
+            x: Buffer.from(publicKeyHex, 'hex').toString('base64url')
+        },
+        format: 'jwk'
+    });
+    return async (request, rawBody) => {
+        const signature = request.headers['x-signature-ed25519'];
+        const timestamp = request.headers['x-signature-timestamp'];
+        let result;
+        if (!signature || !timestamp) {
+            result = { valid: false };
+        }
+        else {
+            const message = Buffer.concat([Buffer.from(timestamp), rawBody]);
+            const signatureBuffer = Buffer.from(signature, 'hex');
+            let valid = false;
+            try {
+                valid = verify(null, message, publicKey, signatureBuffer);
+            }
+            catch {
+                valid = false;
+            }
+            if (valid) {
+                const body = JSON.parse(rawBody.toString('utf-8'));
+                result = { valid: true, body };
+            }
+            else {
+                result = { valid: false };
+            }
+        }
+        return result;
+    };
+}
+
+/**
+ * Service that handles Discord interaction webhook events.
+ *
+ * Verifies incoming webhook signatures and dispatches interactions to registered handlers.
+ */
+let DiscordWebhookService = class DiscordWebhookService {
+    logger = new Logger('DiscordWebhookService');
+    _verifier;
+    handler = discordInteractionHandlerFactory();
+    configure = discordInteractionHandlerConfigurerFactory(this.handler);
+    constructor(discordWebhookServiceConfig) {
+        this._verifier = discordWebhookEventVerifier({
+            publicKey: discordWebhookServiceConfig.discordWebhook.publicKey
+        });
+    }
+    async updateForWebhook(req, rawBody) {
+        const result = await this._verifier(req, rawBody);
+        if (!result.valid) {
+            this.logger.warn('Received invalid Discord interaction event.', req);
+        }
+        else {
+            await this.updateForDiscordInteraction(result.body);
+        }
+    }
+    async updateForDiscordInteraction(interaction) {
+        const result = await this.handler(interaction);
+        if (!result) {
+            this.logger.warn('Received unexpected/unhandled Discord interaction.', interaction);
+        }
+    }
+};
+DiscordWebhookService = __decorate([
+    Injectable(),
+    __param(0, Inject(DiscordWebhookServiceConfig))
+], DiscordWebhookService);
+
+let DiscordWebhookController = class DiscordWebhookController {
+    _discordWebhookService;
+    constructor(discordWebhookService) {
+        this._discordWebhookService = discordWebhookService;
+    }
+    async handleDiscordWebhook(req, rawBody) {
+        await this._discordWebhookService.updateForWebhook(req, rawBody);
+    }
+};
+__decorate([
+    Post(),
+    __param(0, Req()),
+    __param(1, RawBody())
+], DiscordWebhookController.prototype, "handleDiscordWebhook", null);
+DiscordWebhookController = __decorate([
+    Controller('/webhook/discord'),
+    __param(0, Inject(DiscordWebhookService))
+], DiscordWebhookController);
+
+/**
+ * Factory that creates a DiscordWebhookServiceConfig from environment variables.
+ */
+function discordWebhookServiceConfigFactory(configService) {
+    const config = {
+        discordWebhook: {
+            publicKey: configService.get(DISCORD_PUBLIC_KEY_ENV_VAR)
+        }
+    };
+    DiscordWebhookServiceConfig.assertValidConfig(config);
+    return config;
+}
+/**
+ * NestJS module that provides Discord interaction webhook handling.
+ *
+ * Standalone — does not depend on DiscordModule (no bot token needed).
+ * Reads the application public key from the DISCORD_PUBLIC_KEY environment variable.
+ */
+let DiscordWebhookModule = class DiscordWebhookModule {
+};
+DiscordWebhookModule = __decorate([
+    Module({
+        imports: [ConfigModule],
+        controllers: [DiscordWebhookController],
+        providers: [
+            {
+                provide: DiscordWebhookServiceConfig,
+                inject: [ConfigService],
+                useFactory: discordWebhookServiceConfigFactory
+            },
+            DiscordWebhookService
+        ],
+        exports: [DiscordWebhookService]
+    })
+], DiscordWebhookModule);
+
+/**
+ * Default environment variable for the Discord bot token.
+ */
+const DISCORD_BOT_TOKEN_ENV_VAR = 'DISCORD_BOT_TOKEN';
+/**
+ * Default gateway intents for a bot that reads guild messages.
+ *
+ * Includes Guilds, GuildMessages, and MessageContent.
+ * Note: MessageContent is a privileged intent and must be enabled in the Discord Developer Portal.
+ */
+const DISCORD_DEFAULT_INTENTS = [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent];
+/**
+ * Configuration for the DiscordApi service.
+ */
+class DiscordServiceConfig {
+    discord;
+    static assertValidConfig(config) {
+        if (!config.discord.botToken) {
+            throw new Error('No Discord bot token specified.');
+        }
+    }
+}
+
+/**
+ * Injectable service that wraps the discord.js Client for bot operations.
+ *
+ * Automatically logs in on module init and destroys the client on module destroy
+ * when autoLogin is enabled (default).
+ */
+let DiscordApi = class DiscordApi {
+    config;
+    logger = new Logger('DiscordApi');
+    /**
+     * The underlying discord.js Client instance.
+     */
+    client;
+    constructor(config) {
+        this.config = config;
+        const { clientOptions } = config.discord;
+        this.client = new Client({
+            intents: DISCORD_DEFAULT_INTENTS,
+            ...clientOptions
+        });
+    }
+    async onModuleInit() {
+        const { autoLogin = true, botToken } = this.config.discord;
+        let result;
+        if (autoLogin) {
+            result = this.client
+                .login(botToken)
+                .then(() => { })
+                .catch((e) => {
+                this.logger.error('Failed to log in to Discord', e);
+            });
+        }
+        else {
+            result = Promise.resolve();
+        }
+        return result;
+    }
+    async onModuleDestroy() {
+        return this.client.destroy();
+    }
+    /**
+     * Sends a text message to a Discord channel.
+     *
+     * @param channelId - target channel's snowflake ID
+     * @param content - message text to send
+     *
+     * @throws {Error} When the channel is not found or is not a text channel.
+     *
+     * @example
+     * ```ts
+     * const message = await discordApi.sendMessage('123456789', 'Hello from the bot!');
+     * ```
+     */
+    async sendMessage(channelId, content) {
+        const channel = await this.client.channels.fetch(channelId);
+        if (!channel || !(channel instanceof TextChannel)) {
+            throw new Error(`Channel ${channelId} not found or is not a text channel.`);
+        }
+        return channel.send(content);
+    }
+    /**
+     * Registers a handler for the MessageCreate event (incoming messages).
+     *
+     * Returns an unsubscribe function to remove the handler.
+     *
+     * @param handler - callback invoked for each incoming message
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = discordApi.onMessage((message) => {
+     *   if (!message.author.bot) {
+     *     console.log(`${message.author.tag}: ${message.content}`);
+     *   }
+     * });
+     *
+     * // Later, to stop listening:
+     * unsubscribe();
+     * ```
+     */
+    onMessage(handler) {
+        this.client.on(Events.MessageCreate, handler);
+        return () => this.client.off(Events.MessageCreate, handler);
+    }
+};
+DiscordApi = __decorate([
+    Injectable(),
+    __param(0, Inject(DiscordServiceConfig))
+], DiscordApi);
+
+/**
+ * Factory that creates a DiscordServiceConfig from environment variables.
+ */
+function discordServiceConfigFactory(configService) {
+    const config = {
+        discord: {
+            botToken: configService.get(DISCORD_BOT_TOKEN_ENV_VAR),
+            autoLogin: true
+        }
+    };
+    DiscordServiceConfig.assertValidConfig(config);
+    return config;
+}
+/**
+ * NestJS module that provides the DiscordApi service.
+ *
+ * Reads the bot token from the DISCORD_BOT_TOKEN environment variable.
+ */
+let DiscordModule = class DiscordModule {
+};
+DiscordModule = __decorate([
+    Module({
+        imports: [ConfigModule],
+        providers: [
+            {
+                provide: DiscordServiceConfig,
+                inject: [ConfigService],
+                useFactory: discordServiceConfigFactory
+            },
+            DiscordApi
+        ],
+        exports: [DiscordApi]
+    })
+], DiscordModule);
+
+/**
+ * Default number of messages per page when fetching Discord channel messages.
+ */
+const DISCORD_DEFAULT_MESSAGES_PER_PAGE = 100;
+/**
+ * Creates a page factory that wraps a Discord message fetch function with automatic cursor-based pagination.
+ *
+ * Discord paginates via `before`/`after` snowflake IDs. This factory automatically reads the last
+ * message's ID from each response and sets it as the `before` cursor for the next request.
+ * When the number of returned messages is less than the requested limit, pagination stops.
+ *
+ * @param fetch - The Discord fetch function to paginate over
+ * @param config - Optional config for reading message IDs
+ * @param defaults - Optional default configuration for the page factory
+ * @returns A page factory that produces iterable page fetchers
+ *
+ * @example
+ * ```typescript
+ * const pageFactory = discordFetchMessagePageFactory(fetchChannelMessages);
+ *
+ * const fetchPage = pageFactory({ limit: 50 });
+ * const firstPage = await fetchPage.fetchNext();
+ *
+ * if (firstPage.hasNext) {
+ *   const secondPage = await firstPage.fetchNext();
+ * }
+ * ```
+ */
+function discordFetchMessagePageFactory(fetch, config, defaults) {
+    const readMessageId = config?.readMessageId ?? ((message) => message.id);
+    return fetchPageFactory({
+        ...defaults,
+        fetch,
+        readFetchPageResultInfo(result) {
+            const count = result.data.length;
+            const lastMessage = lastValue(result.data);
+            const nextCursor = lastMessage ? readMessageId(lastMessage) : undefined;
+            return {
+                hasNext: count > 0,
+                nextPageCursor: nextCursor
+            };
+        },
+        buildInputForNextPage(pageResult, input, options) {
+            const nextCursor = pageResult.nextPageCursor;
+            const effectiveLimit = options.maxItemsPerPage ?? input.limit ?? DISCORD_DEFAULT_MESSAGES_PER_PAGE;
+            const resultCount = pageResult.result?.data.length ?? 0;
+            // Discord signals no more results when fewer items than the limit are returned
+            if (!nextCursor || resultCount < effectiveLimit) {
+                return undefined;
+            }
+            return {
+                ...input,
+                before: nextCursor,
+                after: undefined,
+                around: undefined,
+                limit: effectiveLimit
+            };
+        }
+    });
+}
+
+/**
+ * Returns default ClientOptions for a bot that reads guild messages.
+ *
+ * Includes Guilds, GuildMessages, and MessageContent intents.
+ *
+ * @example
+ * ```ts
+ * const options = discordDefaultClientOptions();
+ * // options.intents === [GatewayIntentBits.Guilds, GatewayIntentBits.GuildMessages, GatewayIntentBits.MessageContent]
+ * ```
+ */
+function discordDefaultClientOptions() {
+    return {
+        intents: DISCORD_DEFAULT_INTENTS
+    };
+}
+/**
+ * Returns ClientOptions with additional intents merged with the defaults.
+ *
+ * @param additionalIntents - extra intents to include beyond the defaults
+ *
+ * @example
+ * ```ts
+ * const options = discordClientOptionsWithIntents([GatewayIntentBits.DirectMessages]);
+ * // options.intents includes Guilds, GuildMessages, MessageContent, and DirectMessages
+ * ```
+ */
+function discordClientOptionsWithIntents(additionalIntents) {
+    return {
+        intents: [...DISCORD_DEFAULT_INTENTS, ...additionalIntents]
+    };
+}
+
+export { DISCORD_BOT_TOKEN_ENV_VAR, DISCORD_DEFAULT_INTENTS, DISCORD_DEFAULT_MESSAGES_PER_PAGE, DISCORD_PUBLIC_KEY_ENV_VAR, DiscordApi, DiscordModule, DiscordServiceConfig, DiscordWebhookController, DiscordWebhookModule, DiscordWebhookService, DiscordWebhookServiceConfig, discordClientOptionsWithIntents, discordDefaultClientOptions, discordFetchMessagePageFactory, discordInteractionHandlerConfigurerFactory, discordInteractionHandlerFactory, discordServiceConfigFactory, discordWebhookEventVerifier, discordWebhookInteraction, discordWebhookServiceConfigFactory };

package/discord/package.json

@@ -0,0 +1,24 @@
+{
+  "name": "@dereekb/nestjs/discord",
+  "version": "13.2.1",
+  "peerDependencies": {
+    "@dereekb/nestjs": "13.2.1",
+    "@dereekb/util": "13.2.1",
+    "@nestjs/common": "^11.0.0",
+    "@nestjs/config": "^4.0.0",
+    "discord.js": "^14.25.1",
+    "express": "^5.0.0"
+  },
+  "exports": {
+    "./package.json": "./package.json",
+    ".": {
+      "module": "./index.esm.js",
+      "types": "./index.d.ts",
+      "import": "./index.cjs.mjs",
+      "default": "./index.cjs.js"
+    }
+  },
+  "module": "./index.esm.js",
+  "main": "./index.cjs.js",
+  "types": "./index.d.ts"
+}

package/discord/src/index.d.ts

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

package/discord/src/lib/discord.api.d.ts

@@ -0,0 +1,55 @@
+import { Client, type Message } from 'discord.js';
+import { type OnModuleDestroy, type OnModuleInit } from '@nestjs/common';
+import { DiscordServiceConfig } from './discord.config';
+import { type DiscordChannelId } from './discord.type';
+/**
+ * Injectable service that wraps the discord.js Client for bot operations.
+ *
+ * Automatically logs in on module init and destroys the client on module destroy
+ * when autoLogin is enabled (default).
+ */
+export declare class DiscordApi implements OnModuleInit, OnModuleDestroy {
+    readonly config: DiscordServiceConfig;
+    private readonly logger;
+    /**
+     * The underlying discord.js Client instance.
+     */
+    readonly client: Client;
+    constructor(config: DiscordServiceConfig);
+    onModuleInit(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    /**
+     * Sends a text message to a Discord channel.
+     *
+     * @param channelId - target channel's snowflake ID
+     * @param content - message text to send
+     *
+     * @throws {Error} When the channel is not found or is not a text channel.
+     *
+     * @example
+     * ```ts
+     * const message = await discordApi.sendMessage('123456789', 'Hello from the bot!');
+     * ```
+     */
+    sendMessage(channelId: DiscordChannelId, content: string): Promise<Message>;
+    /**
+     * Registers a handler for the MessageCreate event (incoming messages).
+     *
+     * Returns an unsubscribe function to remove the handler.
+     *
+     * @param handler - callback invoked for each incoming message
+     *
+     * @example
+     * ```ts
+     * const unsubscribe = discordApi.onMessage((message) => {
+     *   if (!message.author.bot) {
+     *     console.log(`${message.author.tag}: ${message.content}`);
+     *   }
+     * });
+     *
+     * // Later, to stop listening:
+     * unsubscribe();
+     * ```
+     */
+    onMessage(handler: (message: Message) => void): () => void;
+}

package/discord/src/lib/discord.api.page.d.ts

@@ -0,0 +1,89 @@
+import { type Maybe } from '@dereekb/util';
+import { type FetchPageFactory, type FetchPageFactoryConfigDefaults } from '@dereekb/util/fetch';
+import { type DiscordMessageId } from './discord.type';
+/**
+ * Default number of messages per page when fetching Discord channel messages.
+ */
+export declare const DISCORD_DEFAULT_MESSAGES_PER_PAGE = 100;
+/**
+ * Base pagination parameters for Discord channel message endpoints.
+ *
+ * Discord uses cursor-based pagination via snowflake IDs rather than page numbers.
+ * Only one of `before`, `after`, or `around` should be specified per request.
+ */
+export interface DiscordMessagePageFilter {
+    /**
+     * Fetch messages before this message ID.
+     */
+    readonly before?: Maybe<DiscordMessageId>;
+    /**
+     * Fetch messages after this message ID.
+     */
+    readonly after?: Maybe<DiscordMessageId>;
+    /**
+     * Fetch messages around this message ID.
+     */
+    readonly around?: Maybe<DiscordMessageId>;
+    /**
+     * Maximum number of messages to return per page (1-100).
+     *
+     * Defaults to {@link DISCORD_DEFAULT_MESSAGES_PER_PAGE}.
+     */
+    readonly limit?: Maybe<number>;
+}
+/**
+ * Result of a paginated Discord message fetch containing the array of messages.
+ *
+ * @typeParam T - The message type (typically discord.js `Message`)
+ */
+export interface DiscordMessagePageResult<T> {
+    /**
+     * Array of messages returned.
+     */
+    readonly data: T[];
+}
+/**
+ * A fetch function that accepts {@link DiscordMessagePageFilter} input and returns a {@link DiscordMessagePageResult}.
+ * Used as the underlying data source for {@link discordFetchMessagePageFactory}.
+ */
+export type DiscordFetchMessagePageFetchFunction<I extends DiscordMessagePageFilter, T> = (input: I) => Promise<DiscordMessagePageResult<T>>;
+/**
+ * Configuration for {@link discordFetchMessagePageFactory}.
+ *
+ * @typeParam T - The message type
+ */
+export interface DiscordFetchMessagePageFactoryConfig<T> {
+    /**
+     * Extracts the snowflake ID from a message object. Used to determine the cursor for the next page.
+     *
+     * Defaults to reading the `id` property on the message.
+     */
+    readonly readMessageId?: (message: T) => DiscordMessageId;
+}
+/**
+ * Creates a page factory that wraps a Discord message fetch function with automatic cursor-based pagination.
+ *
+ * Discord paginates via `before`/`after` snowflake IDs. This factory automatically reads the last
+ * message's ID from each response and sets it as the `before` cursor for the next request.
+ * When the number of returned messages is less than the requested limit, pagination stops.
+ *
+ * @param fetch - The Discord fetch function to paginate over
+ * @param config - Optional config for reading message IDs
+ * @param defaults - Optional default configuration for the page factory
+ * @returns A page factory that produces iterable page fetchers
+ *
+ * @example
+ * ```typescript
+ * const pageFactory = discordFetchMessagePageFactory(fetchChannelMessages);
+ *
+ * const fetchPage = pageFactory({ limit: 50 });
+ * const firstPage = await fetchPage.fetchNext();
+ *
+ * if (firstPage.hasNext) {
+ *   const secondPage = await firstPage.fetchNext();
+ * }
+ * ```
+ */
+export declare function discordFetchMessagePageFactory<I extends DiscordMessagePageFilter, T extends {
+    id: string;
+}>(fetch: DiscordFetchMessagePageFetchFunction<I, T>, config?: Maybe<DiscordFetchMessagePageFactoryConfig<T>>, defaults?: Maybe<FetchPageFactoryConfigDefaults>): FetchPageFactory<I, DiscordMessagePageResult<T>>;

package/discord/src/lib/discord.config.d.ts

@@ -0,0 +1,36 @@
+import { type ClientOptions, GatewayIntentBits } from 'discord.js';
+import { type DiscordBotToken } from './discord.type';
+/**
+ * Default environment variable for the Discord bot token.
+ */
+export declare const DISCORD_BOT_TOKEN_ENV_VAR = "DISCORD_BOT_TOKEN";
+/**
+ * Default gateway intents for a bot that reads guild messages.
+ *
+ * Includes Guilds, GuildMessages, and MessageContent.
+ * Note: MessageContent is a privileged intent and must be enabled in the Discord Developer Portal.
+ */
+export declare const DISCORD_DEFAULT_INTENTS: GatewayIntentBits[];
+export interface DiscordServiceApiConfig {
+    /**
+     * The bot token used to authenticate with the Discord gateway.
+     */
+    readonly botToken: DiscordBotToken;
+    /**
+     * discord.js Client options. Intents default to DISCORD_DEFAULT_INTENTS if not provided.
+     */
+    readonly clientOptions?: Partial<ClientOptions>;
+    /**
+     * Whether to automatically call client.login() during module initialization.
+     *
+     * Defaults to true.
+     */
+    readonly autoLogin?: boolean;
+}
+/**
+ * Configuration for the DiscordApi service.
+ */
+export declare abstract class DiscordServiceConfig {
+    readonly discord: DiscordServiceApiConfig;
+    static assertValidConfig(config: DiscordServiceConfig): void;
+}

package/discord/src/lib/discord.module.d.ts

@@ -0,0 +1,13 @@
+import { ConfigService } from '@nestjs/config';
+import { DiscordServiceConfig } from './discord.config';
+/**
+ * Factory that creates a DiscordServiceConfig from environment variables.
+ */
+export declare function discordServiceConfigFactory(configService: ConfigService): DiscordServiceConfig;
+/**
+ * NestJS module that provides the DiscordApi service.
+ *
+ * Reads the bot token from the DISCORD_BOT_TOKEN environment variable.
+ */
+export declare class DiscordModule {
+}