Commands

commands#

const commands: Commands

import { commands } from "@neontechspace/fluxerly"
export function commandGroupExample(client) {
    return commands
        .create({ prefix: "!" })
        .registerGroup({ name: "tools", aliases: ["t"] })
        .register({ name: "ping", execute: ({ reply }) => reply("Pong") }, { group: ["tools"] })
        .attach(client)
}

import { commands, type Client } from "@neontechspace/fluxerly"
export function commandGroupExample(client: Client) {
    return commands
        .create({ prefix: "!" })
        .registerGroup({ name: "tools", aliases: ["t"] })
        .register({ name: "ping", execute: ({ reply }) => reply("Pong") }, { group: ["tools"] })
        .attach(client)
}

import { commands } from "@neontechspace/fluxerly"

export function installPing(client) {
    return commands
        .create({
        prefix: "!",
        parse: commands.parseQuoted,
        onUnmatched: ({ reply }, unmatched) => {
            if (unmatched._tag !== "CommandUnknownName")
                return undefined
            const hint = unmatched.suggestion === undefined ? "" : `. Closest known command: ${unmatched.suggestion}`
            return reply(`Unknown command: ${unmatched.name}${hint}`)
        },
    })
        .register({ name: "ping", execute: ({ reply }) => reply("Pong") })
        .attach(client)
}

import { commands, type Client } from "@neontechspace/fluxerly"

export function installPing(client: Client) {
    return commands
        .create({
            prefix: "!",
            parse: commands.parseQuoted,
            onUnmatched: ({ reply }, unmatched) => {
                if (unmatched._tag !== "CommandUnknownName") return undefined
                const hint = unmatched.suggestion === undefined ? "" : `. Closest known command: ${unmatched.suggestion}`
                return reply(`Unknown command: ${unmatched.name}${hint}`)
            },
        })
        .register({ name: "ping", execute: ({ reply }) => reply("Pong") })
        .attach(client)
}

import { commands } from "@neontechspace/fluxerly"

export function typedCommandExample(client) {
    return commands
        .create({ prefix: "!", parse: commands.parseQuoted, onReject: "reply" })
        .register({
        name: "repeat",
        arguments: {
            mode: { type: "choice", choices: ["fast", "slow"] },
            count: { type: "integer", min: 1, max: 5, default: 1 },
            note: { type: "text", optional: true, rest: true },
        },
        cooldown: { durationMs: 10_000, per: "user" },
        execute: ({ reply, values }) => reply(`${values.count} / ${values.mode} / ${values.note ?? "No note"}`),
    })
        .attach(client)
}

import { commands, type Client } from "@neontechspace/fluxerly"

export function typedCommandExample(client: Client) {
    return commands
        .create({ prefix: "!", parse: commands.parseQuoted, onReject: "reply" })
        .register({
            name: "repeat",
            arguments: {
                mode: { type: "choice", choices: ["fast", "slow"] },
                count: { type: "integer", min: 1, max: 5, default: 1 },
                note: { type: "text", optional: true, rest: true },
            },
            cooldown: { durationMs: 10_000, per: "user" },
            execute: ({ reply, values }) => reply(`${values.count} / ${values.mode} / ${values.note ?? "No note"}`),
        })
        .attach(client)
}

import { orThrow } from "@neontechspace/fluxerly"

export async function commandHelpExample(client, router, channelId) {
    const pages = router.help({ prefix: "!", maxLength: 1_000, include: (command) => command.name !== "admin" })
    // Visibility is not authorization. Each command still needs its own policy
    for (const content of pages)
        orThrow(await client.messages.send(channelId, { content, allowedMentions: {} }))
    // Earlier pages remain sent if a later send fails. This example never retries
}

import { orThrow, type Client, type PrefixCommandRouter } from "@neontechspace/fluxerly"

export async function commandHelpExample(client: Client, router: PrefixCommandRouter, channelId: string) {
    const pages = router.help({ prefix: "!", maxLength: 1_000, include: (command) => command.name !== "admin" })
    // Visibility is not authorization. Each command still needs its own policy
    for (const content of pages) orThrow(await client.messages.send(channelId, { content, allowedMentions: {} }))
    // Earlier pages remain sent if a later send fails. This example never retries
}

guards#

const guards: Guards

BotCommandsOptions#

interface BotCommandsOptions<
    M extends MessageCore = Message,
    S extends Readonly<Record<string, unknown>>
        = Readonly<
            Record<string, CommandArgumentSchema | undefined>
        >
>
    extends PrefixCommandsOptions<M>, HandlerOptions<M>interface BotCommandsOptions<
  M extends MessageCore = Message,
  S extends Readonly<
    Record<string, unknown>
  >
    = Readonly<
      Record<
        string,
        | CommandArgumentSchema
        | undefined
      >
    >
>
  extends PrefixCommandsOptions<
    M
  >, HandlerOptions<M>

commands#

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

| PrefixCommandBatch<M, S>
| ((router: PrefixCommandRouter<M>) => PrefixCommandRouter<M>)| PrefixCommandBatch<M, S>
| ((router: PrefixCommandRouter<M>)
    => PrefixCommandRouter<M>)

onError optional#

Receive command failures, and the reports of the router's own subscription, instead of the client-level onError, as the router attach option does

Those are a failing partitionReady hook, a throwing partition function and an overflow that stops the router (overflow "stop"). With overflow dropOldest, a full queue only writes a Warn record and produces no report

(report: FailureReport) => unknown

partitionReady optional#

Hold the commands of a partition key until its own setup is done, as the client.on option partitionReady does for event handlers

Valid only together with partition, otherwise runBot throws ConfigurationError before any client exists. Before the first waiting message of a key starts, the SDK calls the hook with the key and a signal that aborts when the router's subscription stops. The key's messages stay in the queue without using one of the concurrent command slots until the returned promise settles, while other keys keep running, and the held messages count toward maxPendingMessages and maxPendingBytes. A hook that throws, rejects or returns an Err result reports every waiting message of that key to the onError option of the commands, like a throwing partition function does, without a command name, and those messages run no command

(key: string, signal: AbortSignal) => unknown(key: string, signal: AbortSignal)
  => unknown

Inherited from PrefixCommandsOptions: caseSensitive, cooldowns, ignoreBots, mentionPrefix, onReject, onUnmatched, parse, prefix, use

Inherited from HandlerOptions: concurrency, maxPendingBytes, maxPendingMessages, overflow, partition

CommandArgumentBoolean#

interface CommandArgumentBoolean

optional optional#

Set to true to permit omission and return undefined

A supplied invalid token still rejects

true

type#

Require true or false and return the corresponding boolean

"boolean"

CommandArgumentChannel#

interface CommandArgumentChannel

id#

Decimal ID string without leading zeroes except 0 itself

Complete channel mentions accept nonzero IDs only

string

name#

Nonempty channel name matched exactly

Decimal tokens try IDs before names, while complete channel mentions try IDs only

string

CommandArgumentChannelSelection#

interface CommandArgumentChannelSelection<
    C extends readonly CommandArgumentChannel[]
        = readonly CommandArgumentChannel[]
>interface CommandArgumentChannelSelection<
  C extends readonly CommandArgumentChannel[]
    = readonly CommandArgumentChannel[]
>

candidates#

One to 100 channels with decimal IDs and nonempty names, copied to id and name at registration

C

optional optional#

Set to true to permit omission and return undefined

Supplied unmatched or ambiguous text still rejects

true

type#

Resolve the token against these channel candidates only

"channelChoice"

CommandArgumentChoice#

interface CommandArgumentChoice<
    C extends readonly string[] = readonly string[]
>interface CommandArgumentChoice<
  C extends readonly string[]
    = readonly string[]
>

choices#

One to 100 unique nonempty strings, copied at registration

A literal tuple preserves the allowed-string union in values

C

optional optional#

Set to true to allow omission and produce undefined

An unlisted supplied token is invalid

true

type#

Compare the token to the configured strings without case folding

"choice"

CommandArgumentCustom#

interface CommandArgumentCustom<T = unknown>interface CommandArgumentCustom<
  T = unknown
>

expected optional#

Short description of the expected value, such as a hex color, used in rejection replies

string

optional optional#

Set to true to produce undefined when omitted

true

parse#

Convert the token synchronously, returning undefined for input that should be rejected

Throw or return an Err to fail the command

(token: string) => T | undefined

rest optional#

Set to true to pass the remaining tokens joined with single spaces

This descriptor must be last

true

type#

Convert with the supplied parse function

"custom"

CommandArgumentDuration#

interface CommandArgumentDuration

default optional#

Milliseconds used when the argument is omitted, which makes it optional without adding undefined to its value

number

max optional#

Longest accepted duration in milliseconds, inclusive

number

min optional#

Shortest accepted duration in milliseconds, inclusive

number

optional optional#

Set to true to produce undefined when omitted

true

type#

Produce whole milliseconds, a safe integer, from unit-suffixed duration text

"duration"

wholeSeconds optional#

Set to true to reject a duration with a millisecond part, such as 1m500ms, for a destination that takes whole seconds, such as a ban's durationMs

true

CommandArgumentId#

interface CommandArgumentId

mention optional#

Also accept this mention kind as a complete token

Omitted means accept decimal ID strings only

CommandArgumentMention

optional optional#

Set to true to return undefined when omitted

Supplied malformed IDs or mentions still reject

true

type#

Return the accepted nonzero decimal ID string rather than a number or resource object

"id"

CommandArgumentInteger#

interface CommandArgumentInteger

default optional#

Safe integer used when the argument is omitted, which makes it optional without adding undefined to its value

number

max optional#

Largest accepted value, inclusive

A larger value is rejected as Invalid

number

min optional#

Smallest accepted value, inclusive

A smaller value is rejected as Invalid

number

optional optional#

Set to true to return undefined when omitted

Otherwise this argument is required and must precede optional arguments

true

type#

Require decimal integer syntax and a safe integer result

"integer"

CommandArgumentMember#

interface CommandArgumentMember

optional optional#

Set to true to produce undefined when omitted

true

type#

Produce a member reference from a user mention or ID

"member"

CommandArgumentMetadata#

interface CommandArgumentMetadata

choices optional#

Frozen accepted strings for a choice descriptor

Absent for other types

readonly string[]

default optional#

Value used when the argument is omitted, for descriptors that declare one

number

expected optional#

Short description of the expected value for a custom descriptor, used in rejection replies

Absent for other types

string

max optional#

Inclusive upper bound of an integer, number or duration descriptor, in milliseconds for a duration

Absent without a bound

number

mention optional#

Additional mention kind accepted by an id descriptor, if configured

Generated usage still shows the argument name

CommandArgumentMention

min optional#

Inclusive lower bound of an integer, number or duration descriptor, in milliseconds for a duration

Absent without a bound

number

name#

Schema property name, which also names its converted value

string

optional#

True when the argument can be omitted, producing undefined or its default instead of an error

boolean

rest#

True when this final text or custom argument takes all remaining tokens, joined with spaces

boolean

type#

Conversion applied to this positional token, such as integer or member

CommandArgumentType

wholeSeconds optional#

True for a duration descriptor that rejects a millisecond part

Absent otherwise

true

CommandArgumentNumber#

interface CommandArgumentNumber

default optional#

Finite number used when the argument is omitted, which makes it optional without adding undefined to its value

number

max optional#

Largest accepted value, inclusive

A larger value is rejected as Invalid

number

min optional#

Smallest accepted value, inclusive

A smaller value is rejected as Invalid

number

optional optional#

Set to true to produce undefined when omitted

Leaving this unset requires a token

true

type#

Accept decimal and exponent syntax when conversion produces a finite number

"number"

CommandArgumentParseOptions#

interface CommandArgumentParseOptions

guildId optional#

Community ID that a member descriptor puts in its reference, normally the message's guildId

Without it a member token is rejected, as in a direct message

string

CommandArgumentRole#

interface CommandArgumentRole

id#

Decimal ID string without leading zeroes except 0 itself

Complete role mentions accept nonzero IDs only

string

name#

Nonempty role name matched exactly

Decimal tokens try IDs before names, while complete role mentions try IDs only

string

CommandArgumentRoleSelection#

interface CommandArgumentRoleSelection<
    C extends readonly CommandArgumentRole[]
        = readonly CommandArgumentRole[]
>interface CommandArgumentRoleSelection<
  C extends readonly CommandArgumentRole[]
    = readonly CommandArgumentRole[]
>

candidates#

One to 100 roles with decimal IDs and nonempty names

Registration copies only id and name

C

optional optional#

Set to true to allow omission and return undefined, rather than selecting any role implicitly

true

type#

Resolve the token against these role candidates only, without a permission or hierarchy check

"roleChoice"

CommandArgumentText#

interface CommandArgumentText

optional optional#

Set to true to produce undefined when no token remains

Omitted means required, and false is not a supported option

true

rest optional#

Set to true to join remaining tokens with single spaces

This descriptor must be last. Omitted means consume one token

true

type#

Keep parsed text without numeric or resource conversion

"text"

CommandArgumentUser#

interface CommandArgumentUser

id#

Decimal ID string, either 0 or digits beginning with a nonzero digit

May be selected directly or by a complete user mention with a nonzero ID

string

username#

Nonempty username matched exactly, including case

Decimal tokens try IDs first, then usernames. Complete user mentions try IDs only

string

CommandArgumentUserSelection#

interface CommandArgumentUserSelection<
    C extends readonly CommandArgumentUser[]
        = readonly CommandArgumentUser[]
>interface CommandArgumentUserSelection<
  C extends readonly CommandArgumentUser[]
    = readonly CommandArgumentUser[]
>

candidates#

One to 100 users with nonempty usernames and decimal IDs

Registration copies only id and username

C

optional optional#

Set to true to return undefined when omitted, without choosing a default candidate

true

type#

Resolve a token against these user candidates only

"userChoice"

CommandContextHelpOptions#

interface CommandContextHelpOptions

group optional#

Registered names of the group to describe, such as ["admin"]

Omit for root entries, as in router.help

readonly string[]

include optional#

Return false to leave an entry out, as in router.help

Hidden entries never appear

(command: PrefixCommandMetadata) => boolean(command: PrefixCommandMetadata)
  => boolean

maxLength optional#

Maximum page length in UTF-16 code units, a positive safe integer, default 2,000

number

prefix optional#

Prefix to display, default the prefix that matched the invoking message, such as !

string

CommandCooldownRequest#

interface CommandCooldownRequest

durationMs#

Whole milliseconds to reserve, from 1 through 2,147,483,647

number

key#

Nonempty key combining command identity with the configured key suffix

Use the complete string as the store key

string

CommandHelpOptions#

interface CommandHelpOptions

group optional#

Choose a group by its registered names, not aliases, such as ["admin"]

Omit or use [] for root entries. A selected group shows itself and its immediate children, not deeper descendants. Missing groups fail with ConfigurationError, and so do hidden groups and groups inside them, so help does not reveal them

readonly string[]

include optional#

Return true to show an entry or false to exclude it, for example (entry) => entry.name !== "internal"

Omitted means show each considered entry. Receives frozen metadata, with kind: "group" identifying groups. Entries registered with hidden: true, and everything inside a hidden group, are left out before this callback runs

(command: PrefixCommandMetadata) => boolean(command: PrefixCommandMetadata)
  => boolean

Root help checks immediate entries once each in sibling registration order. A group selection checks ancestors first, then the selected group and its immediate children, at most once per entry. An ancestor or selected group that include rejects returns [] without inspecting later entries. An included empty group remains visible, even if none of its children appear

Excluding an entry from help does not prevent the command from running. Help does not run guards or check cooldowns

A throw fails with ConfigurationError whose cause is the thrown value. A non-boolean or asynchronous return fails with ConfigurationError. Promises are not supported or awaited. Keep this synchronous callback short because it cannot be interrupted while running

maxLength#

Required maximum page length, measured in UTF-16 code units

Use a positive safe integer. There is no default or provider-limit lookup

number

prefix#

Nonempty well-formed prefix to display, such as !

This can differ from dispatch prefixes and does not call the prefix resolver

string

Commands#

interface Commands

create<
    M extends MessageCore = Message
>(options: PrefixCommandsOptions<M>): PrefixCommandRouter<M>create<
  M extends MessageCore = Message
>(
  options: PrefixCommandsOptions<M>
): PrefixCommandRouter<M>

memoryCooldowns(
    options?: MemoryCooldownOptions
): MemoryCooldownStorememoryCooldowns(
  options?: MemoryCooldownOptions
): MemoryCooldownStore

parseArgument<
    D extends
        | CommandArgumentText
        | CommandArgumentInteger
        | CommandArgumentNumber
        | CommandArgumentBoolean
        | CommandArgumentId
        | CommandArgumentChoice<readonly string[]>
        | CommandArgumentUserSelection<
              readonly CommandArgumentUser[]
          >
        | CommandArgumentChannelSelection<
              readonly CommandArgumentChannel[]
          >
        | CommandArgumentRoleSelection<
              readonly CommandArgumentRole[]
          >
        | CommandArgumentMember
        | CommandArgumentDuration
>(
    token: string | undefined,
    descriptor: D,
    options?: CommandArgumentParseOptions
): CommandArgumentValue<D> | undefinedparseArgument<
  D extends
    | CommandArgumentText
    | CommandArgumentInteger
    | CommandArgumentNumber
    | CommandArgumentBoolean
    | CommandArgumentId
    | CommandArgumentChoice<
        readonly string[]
      >
    | CommandArgumentUserSelection<
        readonly CommandArgumentUser[]
      >
    | CommandArgumentChannelSelection<
        readonly CommandArgumentChannel[]
      >
    | CommandArgumentRoleSelection<
        readonly CommandArgumentRole[]
      >
    | CommandArgumentMember
    | CommandArgumentDuration
>(
  token: string | undefined,
  descriptor: D,
  options?:
    CommandArgumentParseOptions
):
  | CommandArgumentValue<D>
  | undefined

parseQuoted<M extends MessageCore = Message>(
    input: PrefixCommandParseInput<M>
): PrefixCommandParse | PrefixCommandParseRejection | undefinedparseQuoted<
  M extends MessageCore = Message
>(
  input: PrefixCommandParseInput<M>
):
  | PrefixCommandParse
  | PrefixCommandParseRejection
  | undefined

suggest(
    name: string,
    candidates: Iterable<string>
): string | undefinedsuggest(
  name: string,
  candidates: Iterable<string>
): string | undefined

CooldownStore#

interface CooldownStore

claim(
    input: CommandCooldownRequest
): CommandCooldownClaim | PromiseLike<CommandCooldownClaim>claim(
  input: CommandCooldownRequest
):
  | CommandCooldownClaim
  | PromiseLike<
      CommandCooldownClaim
    >

Guards#

interface Guards

import { guards, runBot } from "@neontechspace/fluxerly"

export function moderationBot(token) {
    return runBot({
        token,
        commands: {
            prefix: "!",
            commands: {
                purge: {
                    guard: [guards.guildOnly(), guards.requirePermissions(["ManageMessages"])],
                    execute: ({ reply }) => reply("Purging"),
                },
            },
        },
    })
}

import { guards, runBot } from "@neontechspace/fluxerly"

export function moderationBot(token: string | undefined) {
    return runBot({
        token,
        commands: {
            prefix: "!",
            commands: {
                purge: {
                    guard: [guards.guildOnly(), guards.requirePermissions(["ManageMessages"])],
                    execute: ({ reply }) => reply("Purging"),
                },
            },
        },
    })
}

dmOnly<M extends MessageCore = Message>(): PrefixCommandGuard<M>dmOnly<
  M extends MessageCore = Message
>(): PrefixCommandGuard<M>

guildOnly<M extends MessageCore = Message>(): PrefixCommandGuard<M>guildOnly<
  M extends MessageCore = Message
>(): PrefixCommandGuard<M>

ownerOnly<M extends MessageCore = Message>(): PrefixCommandGuard<M>ownerOnly<
  M extends MessageCore = Message
>(): PrefixCommandGuard<M>

ownerOnly<
    M extends MessageCore = Message
>(ownerIds: string | readonly string[]): PrefixCommandGuard<M>ownerOnly<
  M extends MessageCore = Message
>(
  ownerIds:
    | string
    | readonly string[]
): PrefixCommandGuard<M>

requirePermissions<M extends MessageCore = Message>(
    names: readonly (
        | "CreateInstantInvite" | "KickMembers" | "BanMembers"
        | "Administrator" | "ManageChannels" | "ManageGuild"
        | "AddReactions" | "ViewAuditLog" | "PrioritySpeaker"
        | "Stream" | "ViewChannel" | "SendMessages"
        | "SendTtsMessages" | "ManageMessages" | "EmbedLinks"
        | "AttachFiles" | "ReadMessageHistory" | "MentionEveryone"
        | "UseExternalEmojis" | "Connect" | "Speak" | "MuteMembers"
        | "DeafenMembers" | "MoveMembers" | "UseVad"
        | "ChangeNickname" | "ManageNicknames" | "ManageRoles"
        | "ManageWebhooks" | "ManageExpressions" | "ManageThreads"
        | "CreatePublicThreads" | "CreatePrivateThreads"
        | "UseExternalStickers" | "SendMessagesInThreads"
        | "ModerateMembers" | "CreateExpressions" | "PinMessages"
        | "BypassSlowmode" | "UpdateRtcRegion"
        | "ViewChannelMembers")[]
): PrefixCommandGuard<M>requirePermissions<
  M extends MessageCore = Message
>(
  names: readonly (
    | "CreateInstantInvite"
    | "KickMembers" | "BanMembers"
    | "Administrator"
    | "ManageChannels"
    | "ManageGuild"
    | "AddReactions"
    | "ViewAuditLog"
    | "PrioritySpeaker" | "Stream"
    | "ViewChannel"
    | "SendMessages"
    | "SendTtsMessages"
    | "ManageMessages"
    | "EmbedLinks" | "AttachFiles"
    | "ReadMessageHistory"
    | "MentionEveryone"
    | "UseExternalEmojis"
    | "Connect" | "Speak"
    | "MuteMembers"
    | "DeafenMembers"
    | "MoveMembers" | "UseVad"
    | "ChangeNickname"
    | "ManageNicknames"
    | "ManageRoles"
    | "ManageWebhooks"
    | "ManageExpressions"
    | "ManageThreads"
    | "CreatePublicThreads"
    | "CreatePrivateThreads"
    | "UseExternalStickers"
    | "SendMessagesInThreads"
    | "ModerateMembers"
    | "CreateExpressions"
    | "PinMessages"
    | "BypassSlowmode"
    | "UpdateRtcRegion"
    | "ViewChannelMembers")[]
): PrefixCommandGuard<M>

MemoryCooldownOptions#

interface MemoryCooldownOptions

maxEntries optional#

Positive safe integer key limit, defaulting to 10,000

A claim for a new key never fails for lack of space: A full store removes expired keys first, then the reservation that expires soonest, whose key can then claim again early

number

MemoryCooldownStore#

interface MemoryCooldownStore

maxEntries#

Maximum keys this store retains, fixed at creation

number

size#

Current stored-key count

May include expired keys until a full store needs room or an explicit sweep removes them

number

claim(input: CommandCooldownRequest): CommandCooldownClaimclaim(
  input: CommandCooldownRequest
): CommandCooldownClaim

clear(): void

sweep(): number

PrefixCommand#

interface PrefixCommand<
    S extends CommandArgumentSchema = { … },
    M extends MessageCore = Message
>
    extends PrefixCommandDefinitioninterface PrefixCommand<
  S extends CommandArgumentSchema
    = { … },
  M extends MessageCore = Message
>
  extends PrefixCommandDefinition

arguments optional#

Named positional conversions, read in property order

Omitted leaves args unrestricted and values empty

S

cooldown optional#

Optional reservation required after the guards and arguments succeed

A denied claim skips execution

PrefixCommandCooldown<S, M>

execute#

Perform application work after the command is allowed and all arguments convert

Return normally or a promise completing that work. A returned or resolved Err result is reported like a throw, so ({ reply }) => reply("Pong") reports a failed reply. Other successful values are ignored. Throws, rejected promises and Err results use attachment onError reporting, with no automatic retry or cooldown rollback. Pass context.signal to cancellable operations when application work should stop with the subscription

(context: PrefixCommandExecutionContext<S, M>) => unknown(
  context: PrefixCommandExecutionContext<
    S, M
  >
) => unknown

guard optional#

One guard or a list of guards, run in order before argument conversion

The first that denies stops the command. Each command owns its policy, with no inherited group guard or permission from help visibility

PrefixCommandGuard<M> | readonly PrefixCommandGuard<M>[]| PrefixCommandGuard<M>
| readonly PrefixCommandGuard<M>[]

onReject optional#

Feedback after a denied guard, rejected arguments or a denied cooldown claim, overriding the router's onReject

A function receives raw context and a safe rejection classification, not partially converted values. Throws, rejected promises and returned Err results use attachment error reporting, without retry

PrefixCommandRejectionFeedback<M>

Inherited from PrefixCommandDefinition: aliases, description, hidden, name, usage

PrefixCommandContext#

interface PrefixCommandContext<M extends MessageCore = Message>interface PrefixCommandContext<
  M extends MessageCore = Message
>

args#

Parsed string tokens copied to a frozen array, unchanged by subsequent argument conversion

readonly string[]

client#

Client supplied to attach, available for explicit operations

The application remains responsible for connecting and shutting it down

Client<M>

help#

Build help pages from the router that matched this command, for example ({ help, reply }) => reply(help()[0] ?? "No commands")

Takes the same settings as router.help, all optional: The prefix defaults to the one this message used and the page length to 2,000 UTF-16 code units. Nothing is sent. Invalid settings throw ConfigurationError as router.help does

(options?: CommandContextHelpOptions) => readonly string[](options?: CommandContextHelpOptions)
  => readonly string[]

message#

Incoming frozen message with this client's selected fields

The router does not fetch excluded fields

M

name#

Registered command name, even when the message used an alias or different letter case

string

paginate#

Show several pages in this message's channel that the command's author flips with ◀ and ▶ reactions, such as ({ paginate }) => paginate(["First", "Second"])

Delegates to client.messages.paginate with users defaulting to this message's author and this handler's cancellation signal applied, combined with any supplied signal. Pass users to let other people flip, such as () => true for anyone. The other options, defaults, permissions, cleanup and failures are those of client.messages.paginate. The result settles when listening ends, so the handler stays active until then. Returning it from a command callback reports an Err like a thrown error

(pages: readonly PageInput[], options?: PaginateOptions)
    => ResultAsync<
        PaginateResult<M>,
        CancelledError | PaginateFailure
    >(
  pages: readonly PageInput[],
  options?: PaginateOptions
) => ResultAsync<
  PaginateResult<M>,
  CancelledError | PaginateFailure
>

path optional#

Frozen registered names through this command, such as ["admin", "inspect"]

Absent for root commands and does not imply permission

readonly string[]

prefix#

Prefix that matched this message, such as !, !! or the bot mention when mentionPrefix is enabled

string

rawArgs#

Argument text from the parser

The default retains everything after command-name separator whitespace, including trailing whitespace

string

reply#

Reply to the incoming message through the attached client, with this handler's cancellation signal already applied

A string is sent as the reply's content, such as reply("Pong"). Delegates to client.messages.reply, including its validation, deadline, nonce, retry, cache and defect behavior. Cancellation or a lost response can leave the reply posted. An Err does not always mean nothing was sent, and uncertain sends are not replayed. Returning the result from a command callback reports an Err like a thrown error, so ({ reply }) => reply("Pong") needs no further checks

(
    input: string | ReplyInput,
    options?: Omit<RequestOptions, "signal">
) => ResultAsync<M, ConfigurationError | SendError | CancelledError>(
  input: string | ReplyInput,
  options?:
    Omit<RequestOptions, "signal">
) => ResultAsync<
  M,
  | ConfigurationError | SendError
  | CancelledError
>

sendHelp#

Send this router's help in this message's channel, such as ({ sendHelp }) => sendHelp()

Takes the same optional settings as help. One page is sent as a plain message, and several pages use paginate with its defaults, so only the command's author can flip them. Invalid settings, and help with no visible entries, return ConfigurationError without sending anything

(options?: CommandContextHelpOptions)
    => ResultAsync<
        PaginateResult<M>,
        CancelledError | PaginateFailure
    >(options?: CommandContextHelpOptions)
  => ResultAsync<
    PaginateResult<M>,
    CancelledError | PaginateFailure
  >

signal#

Subscription cancellation signal for operations that support it

Cancellation prevents later router callbacks but cannot forcibly stop pending application promises

AbortSignal

PrefixCommandCooldown#

interface PrefixCommandCooldown<
    S extends CommandArgumentSchema = { … },
    M extends MessageCore = Message
>interface PrefixCommandCooldown<
  S extends CommandArgumentSchema
    = { … },
  M extends MessageCore = Message
>

durationMs#

Whole milliseconds per reservation, from 1 through 2,147,483,647

number

key optional#

Return a nonempty key suffix from the converted execution context, replacing the one selected by per

The router adds the command's canonical name or full group path, so aliases share a reservation and different groups remain separate

(context: PrefixCommandExecutionContext<S, M>) => string(
  context: PrefixCommandExecutionContext<
    S, M
  >
) => string

per optional#

Whose invocations share the cooldown: user (default), channel or guild

CommandCooldownPer

store optional#

Store whose claim performs the reservation

Omit it to use the router's own memory store in this process, sized by the router's cooldowns option and shared by every router derived from the same create

CooldownStore

PrefixCommandDefinition#

interface PrefixCommandDefinition

aliases optional#

Other names that run the same command, such as r

Names and aliases must not collide with a command or group in the same parent group

readonly string[]

arguments optional#

Named argument descriptors read in property order after the guard allows execution

Omit this to leave args unconverted and expose empty values

Readonly<Record<string, CommandArgumentDescriptor>>Readonly<
  Record<
    string,
    CommandArgumentDescriptor
  >
>

description optional#

Text placed below the invocation in generated help

The router neither escapes markup nor sends the text

string

hidden optional#

Leave this command out of generated help and unknown-name suggestions, for example for owner-only tools

Defaults to false. A hidden command still runs when invoked by name or alias, so pair it with a guard to restrict who can use it

boolean

name#

Name without the prefix, such as repeat, beginning with an ASCII letter or digit and using only ASCII letters, digits, _ or -

string

usage optional#

Help text after the command name, such as <text> <count>

Overrides argument-derived syntax, including when set to an empty string

string

PrefixCommandExecutionContext#

interface PrefixCommandExecutionContext<
    S extends CommandArgumentSchema = { … },
    M extends MessageCore = Message
>
    extends PrefixCommandContext<M>interface PrefixCommandExecutionContext<
  S extends CommandArgumentSchema
    = { … },
  M extends MessageCore = Message
>
  extends PrefixCommandContext<M>

values#

Frozen values keyed by schema names, such as values.count

Empty when no schema is supplied. Guards and rejection callbacks never receive partial values

CommandArgumentValues<S>

Inherited from PrefixCommandContext: args, client, help, message, name, paginate, path, prefix, rawArgs, reply, sendHelp, signal

PrefixCommandGroupDefinition#

interface PrefixCommandGroupDefinition

aliases optional#

Alternative names for entering this group, matched with the router's caseSensitive setting

readonly string[]

description optional#

Description shown below this group's help entry, without markup escaping or automatic delivery

string

hidden optional#

Leave this group and everything inside it out of generated help and unknown-name suggestions

Defaults to false. Help treats a hidden group like a missing one. Its commands still run when invoked by name, so guard each one that needs it

boolean

name#

Group name using command-name syntax

It must not collide with sibling command or group names and aliases

string

PrefixCommandGroupMetadata#

interface PrefixCommandGroupMetadata
    extends PrefixCommandGroupDefinitioninterface PrefixCommandGroupMetadata
  extends PrefixCommandGroupDefinition

kind#

Distinguishes this non-executable group from a command in help visibility callbacks

"group"

path#

Registered names from the outermost group to this one, such as ["admin", "users"], even if the message used aliases

readonly string[]

Inherited from PrefixCommandGroupDefinition: aliases, description, hidden, name

PrefixCommandMetadata#

interface PrefixCommandMetadata
    extends Omit<PrefixCommandDefinition, "arguments">interface PrefixCommandMetadata
  extends Omit<
    PrefixCommandDefinition,
    "arguments"
  >

arguments optional#

Frozen argument descriptions used to generate usage text, without candidate objects

readonly CommandArgumentMetadata[]

kind optional#

Present for groups supplied to help visibility callbacks

Executable commands omit this property

"group"

path optional#

Registered names from the outer group through this entry, such as ["admin", "inspect"]

Root commands omit this property

readonly string[]

Inherited from PrefixCommandDefinition: aliases, description, hidden, name, usage

PrefixCommandParse#

interface PrefixCommandParse

args#

Positional string tokens in input order, without array holes

A custom parser defines how these tokens are split

readonly string[]

name#

Command name or alias using command-name syntax in the selected parent

A returned group name does not enter that group

string

rawArgs#

Argument text retained for callbacks

The default parser removes whitespace between name and arguments but preserves the remaining text

string

PrefixCommandParseInput#

interface PrefixCommandParseInput<M extends MessageCore = Message>interface PrefixCommandParseInput<
  M extends MessageCore = Message
>

message#

Incoming message with the attached client's selected fields

The router does not fetch omitted fields

M

path optional#

Registered parent group names already selected

Absent at root. Returning another name cannot change this parent

readonly string[]

prefix#

Matched prefix as written, such as !! when both ! and !! match

string

source#

Text after the prefix at root, or after consumed group names and their separator whitespace

Remaining text is not rewritten

string

PrefixCommandParseRejection#

interface PrefixCommandParseRejection

name optional#

The command name the parser read before the mistake, in command-name syntax, which onUnmatched receives as name so a reply can say which command the mistake was for

Omit it when no name was read. Any other value is reported as a parser failure

string

reason#

Nonempty explanation, such as A double quote was opened but never closed

Any other value is reported as a parser failure

string

PrefixCommandParsing#

interface PrefixCommandParsing<M extends MessageCore = Message>interface PrefixCommandParsing<
  M extends MessageCore = Message
>

caseSensitive optional#

Require matching letter case for command and group names and aliases

Defaults to false. This does not change prefix or argument matching

boolean

cooldowns optional#

Size the router's own memory cooldown store, used by commands whose cooldown supplies no store, such as { maxEntries: 50_000 }

Defaults to 10,000 keys, shared by every router derived from the same create. A full store never denies a new key: It removes expired keys first, then the reservation that expires soonest, which lets that key run again early. The same limit bounds the rejections onReject: "reply" remembers so that it does not repeat itself. Invalid options throw ConfigurationError when the router is created

MemoryCooldownOptions

ignoreBots optional#

Skip messages whose author has isBot set, before prefix resolution

Defaults to true

boolean

mentionPrefix optional#

Also accept a mention of the bot, such as @bot ping, as a prefix

Defaults to false. Both mention forms, <@id> and <@!id>, are accepted. The bot's user ID comes from the user in the gateway's READY, so normally no request is needed. When READY did not supply a valid ID, the first message that starts with a mention triggers one users.fetchSelf read, which concurrent messages share. A failed read is logged at Warn in the commands category, and mentions are then treated as ordinary text without a new read for a backoff that starts at 5 seconds and doubles per consecutive failure up to 5 minutes, unless READY supplies the ID first

boolean

parse optional#

Split the command name and arguments, optionally using commands.parseQuoted for quoted words

By default, leading whitespace is trimmed, the name must use command-name syntax and trimmed arguments are split on whitespace. The default preserves rawArgs after removing the command-name separator whitespace. Groups are consumed first using fixed whitespace separators, then this parser runs once on the remaining command text. A custom parser cannot enter another group by returning its name. Return undefined to decline parsing and call optional onUnmatched feedback. Return a PrefixCommandParseRejection instead to decline with a reason that onUnmatched receives, as commands.parseQuoted does for an unclosed quote. A group with no following name reports CommandMissingSubcommand without calling the parser. Throws and malformed results use the attached subscription's error reporting, with no automatic response or retry

(input: PrefixCommandParseInput<M>)
    => PrefixCommandParse | PrefixCommandParseRejection | undefined(input: PrefixCommandParseInput<M>)
  =>
    | PrefixCommandParse
    | PrefixCommandParseRejection
    | undefined

PrefixCommandRegistrationOptions#

interface PrefixCommandRegistrationOptions

group optional#

Registered parent names, not aliases, such as ["admin", "users"]

Omit or use [] for root. Missing parents are not created

readonly string[]

PrefixCommandRouter#

interface PrefixCommandRouter<M extends MessageCore = Message>interface PrefixCommandRouter<
  M extends MessageCore = Message
>

commands#

Frozen command descriptions in registration order across groups, without callbacks or resource candidates

Grouped entries include paths of registered names

readonly PrefixCommandMetadata[]

groups#

Frozen groups in registration order, including empty groups

These names organize lookup and help, not permission checks

readonly PrefixCommandGroupMetadata[]

attach(
    client: Client<M>,
    options?: EventHandlerOptions<unknown>
): Subscriptionattach(
  client: Client<M>,
  options?:
    EventHandlerOptions<unknown>
): Subscription

help(options: CommandHelpOptions): readonly string[]help(
  options: CommandHelpOptions
): readonly string[]

register<
    S extends Readonly<Record<string, CommandArgumentDescriptor>>
        = { … }
>(
    command: PrefixCommand<S, M>,
    options?: PrefixCommandRegistrationOptions
): PrefixCommandRouter<M>register<
  S extends Readonly<
    Record<
      string,
      CommandArgumentDescriptor
    >
  >
    = { … }
>(
  command: PrefixCommand<S, M>,
  options?: PrefixCommandRegistrationOptions
): PrefixCommandRouter<M>

registerGroup(
    group: PrefixCommandGroupDefinition,
    options?: PrefixCommandRegistrationOptions
): PrefixCommandRouter<M>registerGroup(
  group:
    PrefixCommandGroupDefinition,
  options?: PrefixCommandRegistrationOptions
): PrefixCommandRouter<M>

registerMany<S extends Readonly<Record<string, unknown>>>(
    commands: PrefixCommandBatch<M, S>,
    options?: PrefixCommandRegistrationOptions
): PrefixCommandRouter<M>registerMany<
  S extends Readonly<
    Record<string, unknown>
  >
>(
  commands:
    PrefixCommandBatch<M, S>,
  options?: PrefixCommandRegistrationOptions
): PrefixCommandRouter<M>

PrefixCommandUnmatchedContext#

interface PrefixCommandUnmatchedContext<
    M extends MessageCore = Message
>interface PrefixCommandUnmatchedContext<
  M extends MessageCore = Message
>

client#

Attached client available for explicit feedback

The router does not take ownership of its lifetime

Client<M>

message#

Incoming frozen message with the attached client's selected fields only

M

prefix#

Exact prefix selected before parsing declined, name lookup missed or a group needed a subcommand

string

reply#

Reply to the unmatched incoming message through the attached client, with this callback's cancellation signal already applied

A string is sent as the reply's content. Delegates to client.messages.reply, including its validation, deadline, nonce, retry, cache and defect behavior. Cancellation or a lost response can leave the reply posted. An Err does not always mean nothing was sent, and uncertain sends are not replayed. Returning the result from the callback reports an Err like a thrown error

(
    input: string | ReplyInput,
    options?: Omit<RequestOptions, "signal">
) => ResultAsync<M, ConfigurationError | SendError | CancelledError>(
  input: string | ReplyInput,
  options?:
    Omit<RequestOptions, "signal">
) => ResultAsync<
  M,
  | ConfigurationError | SendError
  | CancelledError
>

signal#

Cancellation signal for cooperative feedback work

A promise that ignores it may keep running after the subscription closes

AbortSignal

PrefixCommandsOptions#

interface PrefixCommandsOptions<M extends MessageCore = Message>
    extends PrefixCommandParsing<M>interface PrefixCommandsOptions<
  M extends MessageCore = Message
>
  extends PrefixCommandParsing<M>

onReject optional#

Rejection feedback for commands that do not set their own onReject

Omit it to give no feedback, except in runBot, which replies by default. Guards returning false never send an automatic reply

PrefixCommandRejectionFeedback<M>

onUnmatched optional#

Handle parser declines, unknown names and groups without a subcommand, optionally sending feedback

An unknown name carries a suggestion when a registered name is close, and a parser decline carries a reason and the command name when the parser explained a syntax mistake, such as an unclosed quote from commands.parseQuoted. Return normally or a promise that completes the work. The router does not interpret a successful return value or send a response. The callback runs for every such message and anyone can cause that, so a reply sent from it needs the application's own limit, and in a channel shared with other bots the prefix may belong to a command of another bot. Throws, rejected promises and returned Err results use the attachment's onError reporting, without retry. Not called for ignored bots or messages without a matching prefix

(
    context: PrefixCommandUnmatchedContext<M>,
    unmatched: PrefixCommandUnmatched
) => unknown(
  context:
    PrefixCommandUnmatchedContext<M>,
  unmatched: PrefixCommandUnmatched
) => unknown

prefix#

Prefix text, accepted-prefix list or per-message resolver, which may return a promise

If several prefixes match, the longest wins

PrefixCommandPrefix<M>

use optional#

Middleware run around every matched command, in order

See PrefixCommandMiddleware

readonly PrefixCommandMiddleware<M>[]

Inherited from PrefixCommandParsing: caseSensitive, cooldowns, ignoreBots, mentionPrefix, parse

CommandArgumentDescriptor#

type CommandArgumentDescriptor =
    | CommandArgumentText | CommandArgumentInteger
    | CommandArgumentNumber | CommandArgumentBoolean
    | CommandArgumentId | CommandArgumentChoice
    | CommandArgumentUserSelection | CommandArgumentChannelSelection
    | CommandArgumentRoleSelection | CommandArgumentMember
    | CommandArgumentDuration | CommandArgumentCustomtype CommandArgumentDescriptor =
    | CommandArgumentText
    | CommandArgumentInteger
    | CommandArgumentNumber
    | CommandArgumentBoolean
    | CommandArgumentId
    | CommandArgumentChoice
    | CommandArgumentUserSelection
    | CommandArgumentChannelSelection
    | CommandArgumentRoleSelection
    | CommandArgumentMember
    | CommandArgumentDuration
    | CommandArgumentCustom

CommandArgumentMention#

type CommandArgumentMention = "user" | "channel" | "role"type CommandArgumentMention =
    "user" | "channel" | "role"

CommandArgumentOptionalValue#

type CommandArgumentOptionalValue<
    D extends CommandArgumentDescriptor,
    V
> = D extends { readonly default: number }
    ? V
    : D extends { readonly optional: true } ? V | undefined : Vtype CommandArgumentOptionalValue<
  D extends CommandArgumentDescriptor,
  V
> = D extends {
  readonly default: number
}
  ? V
  : D extends {
  readonly optional: true
}
  ? V | undefined
  : V

CommandArgumentRejectionReason#

type CommandArgumentRejectionReason =
    "Missing" | "Invalid" | "Ambiguous" | "Unexpected"type CommandArgumentRejectionReason =
    | "Missing" | "Invalid"
    | "Ambiguous" | "Unexpected"

CommandArgumentSchema#

type CommandArgumentSchema =
    Readonly<Record<string, CommandArgumentDescriptor>>type CommandArgumentSchema =
    Readonly<
      Record<
        string,
        CommandArgumentDescriptor
      >
    >

CommandArgumentType#

type CommandArgumentType =
    | "text" | "integer" | "number" | "boolean" | "id"
    | "userChoice" | "channelChoice" | "roleChoice" | "choice"
    | "member" | "duration" | "custom"type CommandArgumentType =
    | "text" | "integer" | "number"
    | "boolean" | "id"
    | "userChoice"
    | "channelChoice"
    | "roleChoice" | "choice"
    | "member" | "duration"
    | "custom"

CommandArgumentValue#

type CommandArgumentValue<D extends CommandArgumentDescriptor> =
    D extends CommandArgumentText
        ? CommandArgumentOptionalValue<D, string>
        : D extends CommandArgumentInteger | CommandArgumentNumber
        ? CommandArgumentOptionalValue<D, number>
        : D extends CommandArgumentBoolean
        ? CommandArgumentOptionalValue<D, boolean>
        : D extends CommandArgumentId
        ? CommandArgumentOptionalValue<D, string>
        : D extends CommandArgumentChoice<infer C>
        ? CommandArgumentOptionalValue<D, C[number]>
        : D extends CommandArgumentUserSelection
        ? CommandArgumentOptionalValue<D, CommandArgumentUser>
        : D extends CommandArgumentChannelSelection
        ? CommandArgumentOptionalValue<D, CommandArgumentChannel>
        : D extends CommandArgumentRoleSelection
        ? CommandArgumentOptionalValue<D, CommandArgumentRole>
        : D extends CommandArgumentMember
        ? CommandArgumentOptionalValue<D, MemberReference>
        : D extends CommandArgumentDuration
        ? CommandArgumentOptionalValue<..., ...>
        : ... extends ... ? ... : ...type CommandArgumentValue<
  D extends CommandArgumentDescriptor
> = D extends CommandArgumentText
  ? CommandArgumentOptionalValue<
      D, string
    >
  : D extends
  | CommandArgumentInteger
  | CommandArgumentNumber
  ? CommandArgumentOptionalValue<
      D, number
    >
  : D extends CommandArgumentBoolean
  ? CommandArgumentOptionalValue<
      D, boolean
    >
  : D extends CommandArgumentId
  ? CommandArgumentOptionalValue<
      D, string
    >
  : D extends CommandArgumentChoice<
  infer C
>
  ? CommandArgumentOptionalValue<
      D, C[number]
    >
  : D extends CommandArgumentUserSelection
  ? CommandArgumentOptionalValue<
      D, CommandArgumentUser
    >
  : D extends CommandArgumentChannelSelection
  ? CommandArgumentOptionalValue<
      D,
      CommandArgumentChannel
    >
  : D extends CommandArgumentRoleSelection
  ? CommandArgumentOptionalValue<
      D, CommandArgumentRole
    >
  : D extends CommandArgumentMember
  ? CommandArgumentOptionalValue<
      D, MemberReference
    >
  : D extends CommandArgumentDuration
  ? CommandArgumentOptionalValue<
      ..., ...
    >
  : ... extends ... ? ... : ...

CommandArgumentValues#

type CommandArgumentValues<
    S extends CommandArgumentSchema
> = { readonly [K in keyof S]: CommandArgumentValue<S[K]> }type CommandArgumentValues<
  S extends CommandArgumentSchema
> = {
  readonly [K in keyof S]:
    CommandArgumentValue<S[K]>
}

CommandCooldownClaim#

type CommandCooldownClaim =
    | {
          readonly _tag: "CooldownAcquired"
          readonly retryAtMs: number
      }
    | {
          readonly _tag: "CooldownActive"
          readonly retryAtMs: number
      }type CommandCooldownClaim =
    | {
        readonly _tag:
          "CooldownAcquired"
        readonly retryAtMs: number
      }
    | {
        readonly _tag:
          "CooldownActive"
        readonly retryAtMs: number
      }

CommandCooldownPer#

type CommandCooldownPer = "user" | "channel" | "guild"type CommandCooldownPer =
    "user" | "channel" | "guild"

PrefixCommandBatch#

type PrefixCommandBatch<
    M extends MessageCore,
    S extends Readonly<Record<string, unknown>>
> = {
    readonly [K in keyof S]:
        & Omit<
              PrefixCommand<
                  S[K] extends CommandArgumentSchema ? S[K] : { … },
                  M
              >,
              "name" | "arguments"
          >
        & {
              readonly arguments?: {
                  readonly [A in keyof S[K]]:
                      S[K][A] extends CommandArgumentDescriptor
                          ? S[K][A]
                          : CommandArgumentDescriptor
              }
          }
}type PrefixCommandBatch<
  M extends MessageCore,
  S extends Readonly<
    Record<string, unknown>
  >
> = {
  readonly [K in keyof S]:
    & Omit<
        PrefixCommand<
          S[
            K
          ] extends CommandArgumentSchema
            ? S[K]
            : { … },
          M
        >,
        "name" | "arguments"
      >
    & {
        readonly arguments?: {
          readonly [A in keyof S[K]]:
            S[K][
              A
            ] extends CommandArgumentDescriptor
              ? S[K][A]
              : CommandArgumentDescriptor
        }
      }
}

PrefixCommandGuard#

type PrefixCommandGuard<M extends MessageCore = Message> =
    (context: PrefixCommandContext<M>)
        =>
            | PrefixCommandGuardResult
            | PromiseLike<PrefixCommandGuardResult>type PrefixCommandGuard<
  M extends MessageCore = Message
> = (
  context: PrefixCommandContext<M>
) =>
  | PrefixCommandGuardResult
  | PromiseLike<
      PrefixCommandGuardResult
    >

PrefixCommandGuardResult#

type PrefixCommandGuardResult = boolean | { readonly deny: string }type PrefixCommandGuardResult =
    | boolean
    | { readonly deny: string }

PrefixCommandMiddleware#

type PrefixCommandMiddleware<M extends MessageCore = Message> =
    (context: PrefixCommandContext<M>, next: () => Promise<void>)
        => unknowntype PrefixCommandMiddleware<
  M extends MessageCore = Message
> = (
  context: PrefixCommandContext<M>,
  next: () => Promise<void>
) => unknown

PrefixCommandPrefix#

type PrefixCommandPrefix<M extends MessageCore = Message> =
    | string
    | readonly string[]
    | ((message: M)
          =>
              | PrefixCommandPrefixValue
              | PromiseLike<PrefixCommandPrefixValue>)type PrefixCommandPrefix<
  M extends MessageCore = Message
> =
  | string
  | readonly string[]
  | ((message: M)
      =>
        | PrefixCommandPrefixValue
        | PromiseLike<
            PrefixCommandPrefixValue
          >)

PrefixCommandPrefixValue#

type PrefixCommandPrefixValue =
    string | readonly string[] | undefinedtype PrefixCommandPrefixValue =
    | string
    | readonly string[]
    | undefined

PrefixCommandRejection#

type PrefixCommandRejection =
    | {
          readonly _tag: "CommandGuardRejected"
          readonly reason?: string
      }
    | {
          readonly _tag: "CommandCooldownActive"
          readonly retryAtMs: number
      }
    | {
          readonly _tag: "CommandArgumentRejected"
          readonly argument: string
          readonly reason: CommandArgumentRejectionReason
          readonly retryAtMs?: never
      }type PrefixCommandRejection =
    | {
        readonly _tag:
          "CommandGuardRejected"
        readonly reason?: string
      }
    | {
        readonly _tag:
          "CommandCooldownActive"
        readonly retryAtMs: number
      }
    | {
        readonly _tag:
          "CommandArgumentRejected"
        readonly argument: string
        readonly reason: CommandArgumentRejectionReason
        readonly retryAtMs?: never
      }

PrefixCommandRejectionFeedback#

type PrefixCommandRejectionFeedback<
    M extends MessageCore = Message
> =
    | "reply"
    | "silent"
    | ((
          context: PrefixCommandContext<M>,
          rejection: PrefixCommandRejection
      ) => unknown)type PrefixCommandRejectionFeedback<
  M extends MessageCore = Message
> =
  | "reply"
  | "silent"
  | ((
      context:
        PrefixCommandContext<M>,
      rejection:
        PrefixCommandRejection
    ) => unknown)

PrefixCommandUnmatched#

type PrefixCommandUnmatched =
    | {
          readonly _tag: "CommandUnknownName"
          readonly name: string
          readonly path?: readonly string[]
          readonly suggestion?: string
      }
    | {
          readonly _tag: "CommandParserRejected"
          readonly name?: string
          readonly path?: readonly string[]
          readonly reason?: string
      }
    | {
          readonly _tag: "CommandMissingSubcommand"
          readonly path: readonly string[]
      }type PrefixCommandUnmatched =
    | {
        readonly _tag:
          "CommandUnknownName"
        readonly name: string
        readonly path?:
          readonly string[]
        readonly suggestion?:
          string
      }
    | {
        readonly _tag:
          "CommandParserRejected"
        readonly name?: string
        readonly path?:
          readonly string[]
        readonly reason?: string
      }
    | {
        readonly _tag: "CommandMissingSubcommand"
        readonly path:
          readonly string[]
      }