@neontechspace/fluxerly 1000.0.0-nightly.12

package/dist/api/default/attachments.d.ts

@@ -0,0 +1,89 @@
+import type { Attachment, AttachmentDownloadFailure, AttachmentRefreshFailure, DefaultAttachmentRefreshOptions, DefaultAttachmentDownloadOptions, DefaultAttachmentStreamOptions, RefreshedAttachmentUrl } from "#sdk/attachments";
+import type { ResultAsync, Result } from "neverthrow";
+import type { CancelledError, ConfigurationError } from "#sdk/errors";
+/**
+ * Refresh signed attachment URL strings explicitly, or download received Attachment data all at once or as chunks.
+ * Refresh uses the selected instance's authenticated API. Downloads use its media path, with no gateway connection or cache required.
+ * The SDK never sends bot credentials to a download URL or substitutes attachment.proxyUrl
+ *
+ * @category Messages
+ */
+export interface Attachments {
+    /**
+     * Ask Fluxer's bot-authenticated API to reissue signatures for 1 through 50 URL strings.
+     * Each string may contain at most 2,048 UTF-16 code units.
+     * Strings, duplicate entries and query parameters are sent unchanged
+     *
+     * The frozen result has one original and refreshed pair per input in the same order.
+     * A string outside this instance's attachment URL space is returned unchanged by Fluxer.
+     * Refreshing does not check attachment existence, community or channel membership, permission to download, or media availability
+     *
+     * This method never downloads media and sends the bot credential only to the selected instance's API, never to a requested or refreshed URL.
+     * The credentialed POST follows no redirect.
+     * Use download explicitly afterward for a returned URL that belongs to this instance
+     *
+     * The timeoutMs option defaults to the client's rest.defaultTimeoutMs, 30,000 unless configured, for endpoint discovery, waiting for a REST request slot, rate-limit waits and the limited response read.
+     * A confirmed 429 can retry after its required wait.
+     * A POST with an unknown outcome or a malformed success is not retried automatically.
+     * Cancellation affects only this refresh and waits for request cleanup.
+     * HTTP 404 cannot distinguish an older unsupported deployment from an unavailable route or denied access.
+     * No refresh happens automatically when reading messages or downloading attachments
+     */
+    refreshUrls(urls: readonly string[], options?: DefaultAttachmentRefreshOptions): ResultAsync<readonly RefreshedAttachmentUrl[], AttachmentRefreshFailure | CancelledError | ConfigurationError>;
+    /**
+     * Download attachment.url into one Uint8Array.
+     * Pass maxBytes explicitly, from 1 through 52,428,800 bytes (50 MiB).
+     * The limit caps the returned bytes, not total memory, because response chunks can coexist with the packed result
+     *
+     * The URL must match this instance's discovered media /attachments/ path.
+     * The GET sends no Authorization header, follows no redirects, stores no cached copy and never falls back to proxyUrl.
+     * The timeoutMs option defaults to the client's rest.defaultTimeoutMs, 30,000 unless configured, for endpoint discovery, waiting for a media slot and downloading.
+     * By default four media downloads can run at once (rest.mediaConcurrency), separately from REST and uploads, without waiting for bot API rate limits.
+     * Cancellation waits for response-reader cleanup, but cannot undo bytes already received
+     *
+     * Size and expiry metadata do not prove that the URL is available or the bytes are safe.
+     * Expected failures contain a safe reason and status, including busy, without the URL or response body.
+     * Discovery and download transport failures retain a sanitized cause with a safe transport code when available, never the raw error
+     */
+    download(attachment: Attachment, options: DefaultAttachmentDownloadOptions): ResultAsync<Uint8Array, AttachmentDownloadFailure | CancelledError | ConfigurationError>;
+    /**
+     * Read attachment.url as chunks without combining the file into one array.
+     * Pass maxBytes explicitly, from 1 through 52,428,800 bytes (50 MiB), for the total bytes delivered
+     *
+     * The first pull reads the inputs, resolves endpoints, waits for a media slot (four by default, rest.mediaConcurrency) and starts the GET.
+     * Media slots are separate from the REST and upload slots.
+     * Later pulls read at most one response chunk.
+     * No byte packing, spooling, automatic retry or durable storage is added
+     *
+     * The URL must match this instance's media /attachments/ path.
+     * The GET sends no Authorization header, follows no redirects, caches nothing and never uses proxyUrl.
+     * A Content-Length above maxBytes fails before any chunk, but actual byte counting is still enforced
+     *
+     * The result can be consumed only once.
+     * The timeoutMs option defaults to the client's rest.defaultTimeoutMs, 30,000 unless configured, for the whole download, including pauses between chunks.
+     * Ending consumption early, cancellation, failure and client shutdown cancel the body, wait for reader cleanup and release the media slot.
+     * Expected failures include safe local busy, network, response, limit and deadline reasons and client closure.
+     * Transport failures during discovery, opening or reading retain sanitized causes with safe transport codes when available, never raw errors.
+     * Size and expiry metadata do not establish availability or byte safety
+     *
+     * @remarks
+     * Consume the iterable with a for await loop.
+     * Each item is a Result containing one Uint8Array, and an expected failure yields one Err and ends the loop.
+     * Overlapping next calls return busy without cancelling the pending read.
+     * Breaking the loop, return, throw and signal cancellation all end the download.
+     * Listener or cleanup failures reject with SdkDefect after independent cleanup is attempted
+     *
+     * @example
+     * ```ts
+     * import type { Attachment, Client } from "@neontechspace/fluxerly"
+     * export async function downloadChunks(client: Client, attachment: Attachment) {
+     *     for await (const chunk of client.attachments.stream(attachment, { maxBytes: 1_024 })) {
+     *         if (chunk.isErr()) return chunk
+     *         void chunk.value
+     *     }
+     * }
+     * ```
+     */
+    stream(attachment: Attachment, options: DefaultAttachmentStreamOptions): AsyncIterable<Result<Uint8Array, AttachmentDownloadFailure | CancelledError | ConfigurationError>>;
+}
+//# sourceMappingURL=attachments.d.ts.map

package/dist/api/default/attachments.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.d.ts","sourceRoot":"","sources":["../../../src/api/default/attachments.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,UAAU,EACV,yBAAyB,EACzB,wBAAwB,EACxB,+BAA+B,EAC/B,gCAAgC,EAChC,8BAA8B,EAC9B,sBAAsB,EACzB,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACrD,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErE;;;;;;GAMG;AACH,MAAM,WAAW,WAAW;IACxB;;;;;;;;;;;;;;;;;;;OAmBG;IACH,WAAW,CACP,IAAI,EAAE,SAAS,MAAM,EAAE,EACvB,OAAO,CAAC,EAAE,+BAA+B,GAC1C,WAAW,CAAC,SAAS,sBAAsB,EAAE,EAAE,wBAAwB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACjH;;;;;;;;;;;;;;OAcG;IACH,QAAQ,CACJ,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,gCAAgC,GAC1C,WAAW,CAAC,UAAU,EAAE,yBAAyB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAC3F;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OAqCG;IACH,MAAM,CACF,UAAU,EAAE,UAAU,EACtB,OAAO,EAAE,8BAA8B,GACxC,aAAa,CAAC,MAAM,CAAC,UAAU,EAAE,yBAAyB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAC,CAAA;CACxG"}

package/dist/api/default/attachments.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=attachments.js.map

package/dist/api/default/attachments.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"attachments.js","sourceRoot":"","sources":["../../../src/api/default/attachments.ts"],"names":[],"mappings":""}

package/dist/api/default/audit-logs.d.ts

@@ -0,0 +1,48 @@
+import type { AuditLogEntry, AuditLogPage, AuditLogQuery, AuditLogIterationQuery } from "#sdk/audit-logs";
+import type { PaginationError } from "#sdk/pagination";
+import type { ResultAsync, Result } from "neverthrow";
+import type { GuildOperationFailure, DefaultGuildOperationOptions } from "#sdk/guilds";
+import type { CancelledError, ConfigurationError } from "#sdk/errors";
+/**
+ * Read a community's audit log with ViewAuditLog permission, without connecting the gateway.
+ * The fetchPage method starts immediately.
+ * The iterate method reads pages only when the loop requests them.
+ * The SDK does not cache audit records or create a permanent archive.
+ * Guilds' shared request limits, deadlines and eligible read retries apply.
+ * Input, permission and malformed-response failures return GuildOperationError.
+ * Abort waits for cleanup and returns CancelledError.
+ * Closing clients return ClientClosedError.
+ * Unexpected failures reject with SdkDefect.
+ * Records can change independently between reads
+ *
+ * @category Guilds and members
+ */
+export interface AuditLogs {
+    /**
+     * Fetch one filtered audit page with referenced users and webhook metadata that excludes tokens.
+     * Supply cursors and filters in AuditLogQuery.
+     * A deletion duration that cannot be represented as safe integer milliseconds fails with reason response, without returning a partial page.
+     * The returned page is frozen and remains in memory while the caller retains it
+     */
+    fetchPage(guildId: string, query: AuditLogQuery, options?: DefaultGuildOperationOptions): ResultAsync<AuditLogPage, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Read filtered audit entries newest first, buffering one page and never prefetching.
+     * The maxItems option is required.
+     * The pageSize option defaults to 50 and accepts 1–100, maxPages defaults to 100, and timeoutMs applies to each page.
+     * An empty page or maxItems ends the scan, not a short page.
+     * Invalid traversal input, a stalled cursor or reaching the page budget fails with PaginationError.
+     * Remote failures keep auditLogs.fetchPage's errors.
+     * Deletion durations are rounded to whole milliseconds, and one whose milliseconds are not a safe integer fails its page before that page's entries are delivered.
+     * Each consumption is independent, and client closure releases the page and fails the next pull.
+     * Already delivered entries remain with the caller, and concurrent changes can prevent a complete scan.
+     * Use fetchPage instead to also receive referenced users or webhooks
+     *
+     * @remarks
+     * Consume the iterable with a for await loop, which starts the first request.
+     * An expected failure yields one Err and ends iteration.
+     * Breaking the loop releases the buffered page.
+     * Abort interrupts pending request work and waits for cleanup
+     */
+    iterate(guildId: string, query: AuditLogIterationQuery, options?: DefaultGuildOperationOptions): AsyncIterable<Result<AuditLogEntry, GuildOperationFailure | PaginationError | CancelledError | ConfigurationError>>;
+}
+//# sourceMappingURL=audit-logs.d.ts.map

package/dist/api/default/audit-logs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-logs.d.ts","sourceRoot":"","sources":["../../../src/api/default/audit-logs.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAE,YAAY,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,iBAAiB,CAAA;AACzG,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,iBAAiB,CAAA;AACtD,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,YAAY,CAAA;AACrD,OAAO,KAAK,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErE;;;;;;;;;;;;;GAaG;AACH,MAAM,WAAW,SAAS;IACtB;;;;;OAKG;IACH,SAAS,CACL,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,aAAa,EACpB,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,YAAY,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACzF;;;;;;;;;;;;;;;;;OAiBG;IACH,OAAO,CACH,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,sBAAsB,EAC7B,OAAO,CAAC,EAAE,4BAA4B,GACvC,aAAa,CACZ,MAAM,CAAC,aAAa,EAAE,qBAAqB,GAAG,eAAe,GAAG,cAAc,GAAG,kBAAkB,CAAC,CACvG,CAAA;CACJ"}

package/dist/api/default/audit-logs.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=audit-logs.js.map

package/dist/api/default/audit-logs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"audit-logs.js","sourceRoot":"","sources":["../../../src/api/default/audit-logs.ts"],"names":[],"mappings":""}

package/dist/api/default/bot.d.ts

@@ -0,0 +1,200 @@
+import { ResultAsync } from "neverthrow";
+import { CriticalWorkerStoppedError, type RunBotOptions } from "#sdk/bot-runner";
+import type { ClientOptions } from "#sdk/client";
+import type { CommandArgumentSchema } from "#sdk/command-arguments";
+import { ApplicationError, CancelledError, ConfigurationError, type ConnectError } from "#sdk/errors";
+import type { Message, MessageCore, MessageFields, SelectedMessage, ReplyInput, SendOptions } from "#sdk/messages";
+import type { HandlerOptions, EventMap, EventName } from "#sdk/events";
+import type { FailureReport } from "#sdk/failures";
+import { type DefaultPrefixCommandBatch, type DefaultPrefixCommandRouter, type DefaultPrefixCommandsOptions } from "#sdk/default-commands";
+import { type Client } from "./client.js";
+/**
+ * Data and operations available to one configured bot event handler
+ *
+ * @category Client and lifecycle
+ */
+export type BotEventContext<K extends EventName, M extends MessageCore = Message> = {
+    /** Frozen event payload, using this client's selected message fields where applicable */
+    readonly event: EventMap<M>[K];
+    /** Full client for operations beyond the event's convenience methods. The runner owns its lifetime */
+    readonly client: Client<M>;
+    /** Cancels SDK operations passed this signal when the handler is stopped. It cannot stop arbitrary application Promises */
+    readonly signal: AbortSignal;
+} & (K extends "messageCreate" ? {
+    /** The same incoming message as event */
+    readonly message: M;
+    /** Reply to this message with the handler's cancellation signal already applied. A string is sent as the content.
+     * Uses client.messages.reply without extra retries. Returning the result from the handler reports an Err
+     * like a thrown error, so `({ reply }) => reply("Pong")` needs no further checks.
+     * An uncertain failure can leave a reply posted. Retaining this function does not extend the handler's lifetime
+     */
+    readonly reply: (input: ReplyInput | string, options?: SendOptions) => ReturnType<Client<M>["messages"]["reply"]>;
+} : {});
+/**
+ * A runBot event handler. A returned or resolved Err result is reported like a thrown error, and other return values are ignored
+ *
+ * @category Client and lifecycle
+ */
+export type BotEventHandler<K extends EventName, M extends MessageCore = Message> = (context: BotEventContext<K, M>) => unknown;
+/** A runBot event handler with its own delivery settings.
+ * Omitted settings use the runBot defaults: Overflow dropOldest, concurrency 8 for messageCreate or a partitioned handler and 1 otherwise,
+ * and the client.on queue limits
+ *
+ * @category Client and lifecycle
+ */
+export interface BotEventOptions<K extends EventName, M extends MessageCore = Message> extends HandlerOptions<EventMap<M>[K]> {
+    /** Called for each event */
+    readonly handler: BotEventHandler<K, M>;
+    /** Receive this handler's failures instead of the client-level onError */
+    readonly onError?: (report: FailureReport) => unknown;
+}
+/** One optional handler per event, as a function or an object with a handler and delivery settings.
+ * The runBot function delivers with overflow dropOldest, so a full queue drops the oldest waiting event with a Warn record and a
+ * counter instead of stopping the bot. Handlers for messageCreate run up to eight at a time by default, so they can finish
+ * out of order, and other events run one at a time.
+ * A failed handler is reported with its original error to onError, or logged in full, without stopping the
+ * bot or retrying that handler
+ *
+ * @category Client and lifecycle
+ */
+export type BotEvents<M extends MessageCore = Message> = {
+    readonly [K in EventName]?: BotEventHandler<K, M> | BotEventOptions<K, M> | undefined;
+};
+/**
+ * Prefix commands for runBot: The router options of commands.create, the commands themselves, an optional failure hook
+ * and the delivery settings of the router's attach.
+ * The router is attached before the gateway starts and closed when the bot stops.
+ * The delivery settings concurrency, partition, overflow, maxPendingMessages and maxPendingBytes are passed to attach
+ * unchanged and checked before any client exists. Omitted settings keep the attach defaults: Eight commands at a time
+ * and overflow dropOldest, so a burst drops the oldest waiting message with a Warn record. With overflow "stop", a full
+ * queue stops the bot with CriticalWorkerStoppedError.
+ * Unlike commands.create, runBot replies to a rejected command by default, such as one with a missing argument, as
+ * `onReject: "reply"` does. Set `onReject: "silent"` to send no reply, or a function to give custom feedback.
+ * An unset ignoreBots follows the runBot ignoreBots setting
+ *
+ * @category Commands
+ */
+export interface BotCommandsOptions<M extends MessageCore = Message, S extends Readonly<Record<string, unknown>> = Readonly<Record<string, CommandArgumentSchema | undefined>>> extends DefaultPrefixCommandsOptions<M>, HandlerOptions<M> {
+    /**
+     * Commands keyed by name, such as `{ ping: { execute: ({ reply }) => reply("Pong") } }`, or a callback that
+     * receives the empty router and returns it with registrations, for groups or commands built elsewhere.
+     * The callback runs synchronously inside runBot. Invalid registrations and a return value other than the registered
+     * router throw ConfigurationError. Any other throw from the callback creates no client, and runBot returns an Err
+     * ApplicationError whose source is "runBot commands" and whose cause is the thrown value
+     */
+    readonly commands: DefaultPrefixCommandBatch<M, S> | ((router: DefaultPrefixCommandRouter<M>) => DefaultPrefixCommandRouter<M>);
+    /** Receive command failures instead of the client-level onError, as the router attach option does */
+    readonly onError?: (report: FailureReport) => unknown;
+}
+/**
+ * Configure a bot: Client settings, event handlers, prefix commands, optional startup work and stop signals.
+ * A missing token or a commands-registration failure reported before client creation uses the configured logging
+ * settings and masks the normalized token, including a token enclosed in matching quotes. Other misuse and
+ * option-getter failures instead throw synchronously without a runner report or exit-status change
+ *
+ * @category Client and lifecycle
+ */
+export interface BotOptions<F extends MessageFields | undefined = undefined, S extends Readonly<Record<string, unknown>> = Readonly<Record<string, CommandArgumentSchema | undefined>>> extends ClientOptions<F>, RunBotOptions {
+    /** Handlers registered before connecting and closed when the bot stops.
+     * Own enumerable entries are read once when runBot is called. Undefined handlers are skipped.
+     * Pass a function, or an object with a handler and its own delivery settings.
+     * By default messageCreate runs up to 8 callbacks at a time and other events 1, and a full queue drops the oldest
+     * waiting event with a Warn record instead of stopping the bot.
+     * Bot-authored messageCreate and messageUpdate events skip these handlers unless ignoreBots is false
+     */
+    readonly events?: BotEvents<SelectedMessage<F>>;
+    /**
+     * Skip messageCreate and messageUpdate events whose author is a bot, including this bot's own messages, before they
+     * reach the events handlers or prefix commands. Defaults to true, so a reply cannot trigger its own handler.
+     * Set false for a bridge or logging bot that handles every message, and check message.author.isBot where needed.
+     * Prefix commands follow the same setting unless commands.ignoreBots sets its own.
+     * A value other than a boolean throws ConfigurationError
+     */
+    readonly ignoreBots?: boolean;
+    /** Prefix commands registered and attached before connecting. See BotCommandsOptions */
+    readonly commands?: BotCommandsOptions<SelectedMessage<F>, S>;
+    /**
+     * Startup work after events and commands are registered and before the gateway connects, such as extra subscriptions,
+     * cache warm-up or scheduled tasks. The bot connects only after a returned promise settles, so no handler runs before setup finishes.
+     * Start timers and background work with client.schedule, whose tasks belong to the bot: A requested stop lets their
+     * running work finish within drainMs, every stop cancels the rest, and a failure reaches onError or the log.
+     * The signal aborts when the bot begins stopping for any reason, including a requested stop before its drain, a
+     * failure and a stop while setup is still running. Pass it to SDK operations, or listen for its abort event to end
+     * other work started here, which the runner does not track or await.
+     * A throw, rejection or returned or resolved Err result stops the bot before connecting, and runBot returns an Err
+     * ApplicationError whose source is "runBot setup" and whose cause is the original value, such as the
+     * GuildOperationError of a failed read. A thrown SdkDefect remains a defect and rejects with SdkDefect.
+     * The Effect API runs setup in the bot's Scope instead, so its finalizers and scoped fibers end with the bot
+     */
+    readonly setup?: (client: Client<SelectedMessage<F>>, context: {
+        readonly signal: AbortSignal;
+    }) => unknown;
+}
+/**
+ * Start a bot from event handlers and prefix commands, and watch its connection and subscriptions.
+ * The client is created and every handler and command is registered synchronously, before this function returns and
+ * before the gateway connects, so no event is missed and no handler runs before registration and setup complete.
+ * Invalid options, such as a misspelled option key, an unknown event name, invalid delivery settings or an invalid
+ * command, throw ConfigurationError at once. Every option is checked before any client, signal listener or request
+ * exists, even when the signal is already aborted, so misuse leaves nothing to clean up.
+ * A missing or empty token, usually from an unset environment variable, is reported like a failed run instead: Once
+ * every other option is valid, runBot returns an Err ConfigurationError with field token before any client exists.
+ * The returned ResultAsync then runs the bot until it stops.
+ * Handler contexts expose the full client. Message-create contexts also expose message and a cancellation-aware reply.
+ * Handler and command failures are reported to onError, or logged in full, without restarting them or stopping the bot.
+ * By default, SIGINT and SIGTERM request a normal stop and messages written by bots skip the events handlers and
+ * prefix commands. Set processSignals or ignoreBots to false to opt out. Stopping waits for SDK cleanup, not unrelated application Promises.
+ * Expected runner failures return Err, including ApplicationError when the setup callback or a commands register
+ * callback fails and ConfigurationError for a missing token, and SDK defects reject with SdkDefect.
+ * By default a failed run is also logged once, with code lifecycle.botFailed unless the client already logged that
+ * error, and sets process.exitCode to 1, so `await runBot({...})` needs no further handling.
+ * Set reportFailure to false when the application handles the returned failure and exit status itself.
+ * A missing token or a commands-registration failure reported before client creation uses the configured logging
+ * settings, prints no stack for the missing token and masks the token after removing surrounding whitespace and one pair
+ * of matching quotes. Unusable logging settings are misuse.
+ * An option getter that throws while the options are checked throws SdkDefect with code application.defect and the
+ * thrown value as the cause, before any client exists. Other misuse and option-getter failures throw synchronously
+ * without a runner report or exit-status change, regardless of reportFailure
+ *
+ * @remarks
+ * Aborting the optional signal requests a normal stop, not a cancellation Err. A requested stop first stops accepting
+ * events and lets running handlers, scheduled tasks and their requests finish for up to drainMs, default 5,000 ms. Success means the client has
+ * stopped and cleanup has finished. The runner always shuts down its client, including after a failure.
+ * If an event or command subscription closes while the bot is still running, the result fails with
+ * CriticalWorkerStoppedError. That includes a handler or command router set to overflow "stop" whose queue overflows.
+ * The overflow is still reported to onError or logged, and the error names the event and the exceeded capacity, with
+ * the EventOverflowError as its cause.
+ * Process signal listeners are removed when the run finishes, and the runner never exits the process
+ *
+ * @example
+ * ```ts
+ * import { runBot } from "@neontechspace/fluxerly"
+ *
+ * export function pingBot(token: string | undefined) {
+ *     return runBot({
+ *         token,
+ *         commands: {
+ *             prefix: "!",
+ *             commands: {
+ *                 ping: { execute: ({ reply }) => reply("Pong!") },
+ *                 roll: {
+ *                     arguments: { sides: { type: "integer", min: 2, max: 100, default: 6 } },
+ *                     execute: ({ reply, values }) => reply(`${1 + Math.floor(Math.random() * values.sides)}`),
+ *                 },
+ *             },
+ *         },
+ *     })
+ * }
+ * ```
+ *
+ * @category Client and lifecycle
+ */
+export declare function runBot<const F extends MessageFields | undefined = undefined, const S extends Readonly<Record<string, unknown>> = Readonly<Record<string, CommandArgumentSchema | undefined>>>(options: BotOptions<F, S>): ResultAsync<void, ConnectError | CancelledError | CriticalWorkerStoppedError | ApplicationError | ConfigurationError>;
+/**
+ * Register runBot events and commands on a test client with the same checks, contexts and registration as runBot,
+ * returning the setup work that the test client runs before it connects, given the signal that aborts when the test
+ * client stops. Used by the testing entry point.
+ * Misuse throws ConfigurationError, and a commands register callback's own failure throws its ApplicationError
+ */
+export declare function installTestBot<M extends MessageCore>(client: Client<M>, options: Pick<BotOptions, "events" | "ignoreBots" | "commands" | "setup">): (signal: AbortSignal) => Promise<void>;
+//# sourceMappingURL=bot.d.ts.map

package/dist/api/default/bot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bot.d.ts","sourceRoot":"","sources":["../../../src/api/default/bot.ts"],"names":[],"mappings":"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"}