🥮 mooncakes.io

    gaato/discord/app does not have a README file

    CommandCheck

    source
    type CommandCheck = (CheckCtx) -> Bool raise HandlerError

    A command guard. Returning false produces HandlerError::CheckFailed; expected denials can instead raise a more specific HandlerError.

    ComponentWaiter

    source
    type ComponentWaiter = async (String, Int?) -> 
    ComponentCtx    ?

    Executor-provided lookup behind wait_for_component: resolves the next component interaction matching a custom id, with an optional timeout in milliseconds.

    ErrorPolicy

    source
    type ErrorPolicy = async (FailureCtx, Error) -> Unit

    Policy invoked for interaction, event, and service failures.

    InteractionMiddleware

    source
    type InteractionMiddleware = async (InteractionCtx, async () -> Unit) -> Unit

    Middleware around interaction dispatch: receives the read-only context and a next continuation. Call next() to continue the chain; skip it (typically after InteractionCtx::respond) to short-circuit the handler.

    Spawner

    source
    type Spawner = async (async () -> Unit) -> Unit

    Executor-provided function that runs a handler task concurrently on the surrounding async runtime.

    AppConfigError

    source
    pub(all) suberror AppConfigError {
      EmptyToken
      DuplicateCommand(name~ : String)
      DuplicateCommandPath(command~ : String, path~ : String)
      NestedSubcommandGroup(command~ : String, path~ : String)
      ChoicesWithAutocomplete(command~ : String, path~ : String)
      RequiredOptionAfterOptional(command~ : String, path~ : String)
      InvalidModalFieldCount(custom_id~ : String, count~ : Int)
      DuplicateModalTextInput(custom_id~ : String, field~ : String)
      InvalidCooldown(command~ : String, seconds~ : Int)
      InvalidMaxInFlight(value~ : Int)
    } derive(
    Debug    )

    Configuration errors detected before starting an application executor.

    AppDispatchError

    source
    pub(all) suberror AppDispatchError {
      Failure(command~ : String, phase~ : ResponsePhase, source~ : Error)
    } derive(
    Debug    )

    A command dispatch failure with its response phase and original cause.

    HandlerError

    source
    pub(all) suberror HandlerError {
      UserMessage(message~ : String, ephemeral~ : Bool)
      GuildOnly
      DmOnly
      CheckFailed
      MissingPermission(
    Permissions    )
      OnCooldown(retry_after_ms~ : Int64)
      InvalidArgument(String)
    } derive(
    Debug    )

    Expected command failures that an error policy can present to the user.

    Raise these from handlers, checks, or app middleware; the application's ErrorPolicy turns them into user-facing responses. A permission guard computed with @util.channel_permissions typically raises MissingPermission:

    test "guard a handler with a permission requirement" {
      fn require_send_messages(permissions : @model.Permissions) -> Unit raise {
        let required = @model.Permissions::send_messages()
        if !permissions.contains(required) {
          raise @app.HandlerError::MissingPermission(required)
        }
      }

      try require_send_messages(@model.Permissions::none()) catch {
        @app.HandlerError::MissingPermission(_) => ()
        other => raise other
      } noraise {
        _ => fail("expected MissingPermission")
      }
    }

    ModalPrefillError

    source
    pub(all) suberror ModalPrefillError {
      UnknownCustomId(custom_id~ : String)
      NonTextInput(custom_id~ : String)
    } derive(
    Debug    )

    Invalid per-show text-input prefill configuration.

    App

    source
    pub struct App {
      // private fields
    }

    Gateway-free application declarations shared by gateway and HTTP executors.

    App::App

    source
    fn App::App(sync? : CommandSync, max_in_flight? : Int) -> App

    Create an application core. sync picks the command-sync strategy applied by sync_commands (default: overwrite global commands); max_in_flight caps concurrently running interaction handlers.

    App::attach

    source

    Wire every registered command, component, modal, and autocomplete route into framework and return the AppCtx shared by handlers. Called by the built-in executors (Bot, the HTTP endpoint); only custom executors need it directly.

    App::autocomplete

    source
    fn App::autocomplete(self : App, name : String, handler : async (
    AutocompleteCtx    ) -> Unit) -> Unit

    Register a raw autocomplete handler. A raw handler takes precedence over Arg-level suggest handlers registered for the same command name.

    App::command

    source
    fn[A] App::command(self : App, command : Command[A]) -> Unit

    Register a typed slash or context-menu command built with the command / user_command / message_command builders.

    App::error_policy

    source
    fn App::error_policy(self : App, policy : async (FailureCtx, Error) -> Unit) -> Unit

    Replace the error policy invoked when a handler raises. The default policy maps HandlerError variants to ephemeral user-facing messages and warns about everything else.

    App::middleware

    source
    fn App::middleware(self : App, middleware : async (InteractionCtx, async () -> Unit) -> Unit) -> Unit

    Install middleware around every command, component, and modal handler (not autocomplete). First installed is outermost. Runs inside the error policy: raising HandlerError behaves exactly like a failing check.

    App::on_component

    source
    fn App::on_component(self : App, prefix~ : String, handler : ComponentHandler) -> Unit

    Route component interactions whose custom id starts with prefix to handler. Longer prefixes win when several match.

    App::on_modal

    source
    fn[A] App::on_modal(self : App, modal : Modal[A], handler : ModalSubmitHandler[A]) -> Unit

    Route submissions of the typed modal to handler; field values are decoded through the modal's ModalFields before the handler runs.

    App::on_modal_raw

    source
    fn App::on_modal_raw(self : App, prefix~ : String, handler : async (
    ModalCtx    ) -> Unit) -> Unit

    Register a fully raw modal route without a typed modal definition.

    App::on_warn

    source
    fn App::on_warn(self : App, hook : (String) -> Unit) -> Unit

    Replace the warning hook used for non-fatal diagnostics (default: println).

    App::register

    source
    fn App::register(self : App, command : RegisteredCommand) -> Unit

    Register a type-erased command. App::command is the typed entry point; use this when composing pre-erased commands, e.g. from a plugin.

    App::report_failure

    source
    async fn App::report_failure(self : App, origin : FailureOrigin, error : Error) -> Unit

    Run the error policy for a failure raised outside interaction dispatch. Executors use this for event and service handlers; the policy context has no response target in that case.

    App::serve

    source

    Build a gateway-free dispatcher.

    When client is omitted, the endpoint owns a client created from token and closes it when group finishes. When application_id is omitted, this method always resolves it through GET /applications/@me, including when sync is false. Supplying both values avoids startup HTTP requests when synchronization is disabled.

    If sync is true, command synchronization follows the app's CommandSync setting; CommandSync::Disabled still performs no synchronization.

    App::spawner

    source
    fn App::spawner(self : App, group : 
    TaskGroup    [Unit]) -> (async (async () -> Unit) -> Unit)

    Create a bounded task spawner for an executor-owned task group.

    App::sync_commands

    source

    Push the declared command set to Discord following the CommandSync strategy chosen at construction: global, one or more guilds, or disabled.

    App::validate

    source
    fn App::validate(self : App) -> Unit raise AppConfigError

    Check declarations for configuration errors: invalid command trees and cooldowns, invalid modal field counts, and duplicate modal text-input ids. Executors call this at startup; call it directly in a test to fail fast.

    App::warn

    source
    fn App::warn(self : App, message : String) -> Unit

    Emit a message through the app's warning hook.

    AppCtx

    source
    pub struct AppCtx {
      // private fields
    }

    Transport-neutral services available to interaction handlers.

    Executors construct these values; the public API exposes read-only accessors.

    AppCtx::application_id

    source

    The application id learned during startup.

    AppCtx::application_ref

    source

    The current application bound to its Discord REST client.

    AppCtx::http

    source

    The Discord REST client used by this application.

    AppCtx::latency_ms

    source
    fn AppCtx::latency_ms(self : AppCtx) -> Int64?

    The latest gateway heartbeat round-trip time in milliseconds. For a multi-shard bot, this is the arithmetic mean of shards that have measured latency. HTTP interaction executors and gateway connections awaiting their first heartbeat acknowledgement return None; use GatewayCtx::latency_ms() when the exact value for one shard is required.

    CheckCtx

    source
    pub struct CheckCtx {
      // private fields
    }

    Read-only context passed to command checks before argument decoding and handler execution.

    CheckCtx::guild_id

    source

    The guild the interaction was invoked in, or None outside guilds. Use guild_scope() for flows that require a guild; this accessor is for maybe-guild flows where DMs are valid.

    CheckCtx::guild_scope

    source

    The validated guild invocation. In a DM this raises HandlerError::GuildOnly, which the error policy renders normally.

    CheckCtx::interaction

    source

    The full interaction payload.

    CheckCtx::scope

    source

    Guild or DM invocation scope, carrying the invoking member or user.

    CheckCtx::user

    source

    The invoking user.

    Command

    source
    pub struct Command[A] {
      // private fields
    }

    An application-command definition with a context-aware decoder.

    Command::check

    source
    fn[A] Command::check(self : Command[A], check : (CheckCtx) -> Bool raise HandlerError) -> Command[A]

    Add a pre-execution check. Checks run in registration order before argument decoding. Returning false is equivalent to HandlerError::CheckFailed.

    Command::cooldown

    source
    fn[A] Command::cooldown(self : Command[A], seconds~ : Int, bucket? : CooldownBucket) -> Command[A]

    Apply a fixed-window cooldown to this command. The window starts when all checks pass, before argument decoding and handler execution.

    Command::erase

    source
    fn[A] Command::erase(self : Command[A]) -> RegisteredCommand

    Erase the decoded argument type while retaining registration and dispatch.

    Command::spec

    source

    The command registration specification.

    CommandReply

    source
    pub(all) enum CommandReply {
      Message(InitialResponse)
      ShowModal(ModalHandle)
    }

    An initial response returned by an immediate command handler.

    CommandReply::message

    source

    Construct an immediate message reply.

    CommandSync

    source

    Where application commands are synchronized after the first READY.

    ComponentDeferredCtx

    source
    pub struct ComponentDeferredCtx {
      // private fields
    }

    Component context available after a deferred callback.

    ComponentDeferredCtx::app

    source

    The app-level services: the REST client and application id.

    ComponentDeferredCtx::custom_id

    source
    fn ComponentDeferredCtx::custom_id(self : ComponentDeferredCtx) -> String

    The full custom id of the component that fired.

    ComponentDeferredCtx::edit_original

    source

    Edit the original response after deferring. For DeferredUpdate handlers this edits the component's host message.

    ComponentDeferredCtx::followup

    source

    Send a followup message after the initial deferred response.

    ComponentDeferredCtx::guild_id

    source

    The guild the interaction was invoked in, or None outside guilds. Use guild_scope() for flows that require a guild; this accessor is for maybe-guild flows where DMs are valid.

    ComponentDeferredCtx::guild_scope

    source

    The validated guild invocation. In a DM this raises HandlerError::GuildOnly, which the error policy renders normally.

    ComponentDeferredCtx::interaction

    source

    The full interaction payload.

    ComponentDeferredCtx::message

    source

    The message hosting the component.

    ComponentDeferredCtx::raw

    source

    Escape hatch for advanced inspection. Calling response methods on the raw value opts out of this wrapper's response discipline.

    ComponentDeferredCtx::scope

    source

    Guild or DM invocation scope, carrying the invoking member or user.

    ComponentDeferredCtx::selected_channels

    source

    Resolved partial channel objects for a channel select.

    ComponentDeferredCtx::selected_roles

    source

    Resolved role objects for a role or mentionable select.

    ComponentDeferredCtx::selected_users

    source

    Resolved user objects for a user or mentionable select.

    ComponentDeferredCtx::suffix

    source
    fn ComponentDeferredCtx::suffix(self : ComponentDeferredCtx) -> String

    The custom id with this route's registered prefix stripped (the full id when it does not start with the prefix).

    ComponentDeferredCtx::user

    source

    The invoking user.

    ComponentDeferredCtx::values

    source
    fn ComponentDeferredCtx::values(self : ComponentDeferredCtx) -> Array[String]

    The raw string values selected in a select menu (empty for buttons).

    ComponentDeferredCtx::wait_for_component

    source
    async fn ComponentDeferredCtx::wait_for_component(self : ComponentDeferredCtx, custom_id~ : String, timeout_ms? : Int) -> 
    ComponentCtx    ?

    Wait for the next component interaction with an exact custom id. Returns None on timeout, or immediately when running without a gateway connection.

    ComponentHandler

    source
    pub(all) enum ComponentHandler {
      Immediate(async (ComponentImmediateCtx) -> ComponentReply)
      DeferredUpdate(async (ComponentDeferredCtx) -> Unit)
      DeferredMessage(ephemeral~ : Bool, async (ComponentDeferredCtx) -> Unit)
      Raw(async (
    ComponentCtx    ) -> Unit)
    }

    Execution strategy for a component route.

    ComponentImmediateCtx

    source
    pub struct ComponentImmediateCtx {
      // private fields
    }

    Read-only component context for handlers returning their initial callback.

    ComponentImmediateCtx::app

    source

    The app-level services: the REST client and application id.

    ComponentImmediateCtx::custom_id

    source
    fn ComponentImmediateCtx::custom_id(self : ComponentImmediateCtx) -> String

    The full custom id of the component that fired.

    ComponentImmediateCtx::guild_id

    source

    The guild the interaction was invoked in, or None outside guilds. Use guild_scope() for flows that require a guild; this accessor is for maybe-guild flows where DMs are valid.

    ComponentImmediateCtx::guild_scope

    source

    The validated guild invocation. In a DM this raises HandlerError::GuildOnly, which the error policy renders normally.

    ComponentImmediateCtx::interaction

    source

    The full interaction payload.

    ComponentImmediateCtx::message

    source

    The message hosting the component.

    ComponentImmediateCtx::raw

    source

    Escape hatch for advanced inspection. Calling response methods on the raw value opts out of this wrapper's response discipline.

    ComponentImmediateCtx::scope

    source

    Guild or DM invocation scope, carrying the invoking member or user.

    ComponentImmediateCtx::selected_channels

    source

    Resolved partial channel objects for a channel select.

    ComponentImmediateCtx::selected_roles

    source

    Resolved role objects for a role or mentionable select.

    ComponentImmediateCtx::selected_users

    source

    Resolved user objects for a user or mentionable select.

    ComponentImmediateCtx::suffix

    source
    fn ComponentImmediateCtx::suffix(self : ComponentImmediateCtx) -> String

    The custom id with this route's registered prefix stripped (the full id when it does not start with the prefix).

    ComponentImmediateCtx::user

    source

    The invoking user.

    ComponentImmediateCtx::values

    source
    fn ComponentImmediateCtx::values(self : ComponentImmediateCtx) -> Array[String]

    The raw string values selected in a select menu (empty for buttons).

    ComponentReply

    source
    pub(all) enum ComponentReply {
      UpdateMessage(content~ : String?, embeds~ : Array[
    Embed    ]?, components~ : Array[
    Component    ]?, allowed_mentions~ : 
    AllowedMentions    ?)
      Message(InitialResponse)
      ShowModal(ModalHandle)
    }

    Initial response returned by an immediate component handler.

    ComponentReply::message

    source

    Reply with a new message; set ephemeral=true to show it only to the invoking user.

    ComponentReply::update_message

    source

    Reply by editing the message that hosts the component.

    CooldownBucket

    source
    pub(all) enum CooldownBucket {
      User
      Guild
      Global
    } derive(Eq, 
    Debug    )

    Identity used to share a fixed-window command cooldown.

    DeferredCtx

    source
    pub struct DeferredCtx {
      // private fields
    }

    Command context made available after the initial deferred response.

    DeferredCtx::app

    source
    fn DeferredCtx::app(self : DeferredCtx) -> AppCtx

    The app-level services: the REST client and application id.

    DeferredCtx::edit_original

    source

    Edit the original response after deferring.

    DeferredCtx::followup

    source

    Send a followup message after the initial deferred response.

    DeferredCtx::guild_id

    source

    The guild the interaction was invoked in, or None outside guilds. Use guild_scope() for flows that require a guild; this accessor is for maybe-guild flows where DMs are valid.

    DeferredCtx::guild_scope

    source

    The validated guild invocation. In a DM this raises HandlerError::GuildOnly, which the error policy renders normally.

    DeferredCtx::interaction

    source

    The full interaction payload.

    DeferredCtx::raw

    source

    Escape hatch for advanced inspection. Calling response methods on the raw value opts out of this wrapper's response discipline.

    DeferredCtx::scope

    source

    Guild or DM invocation scope, carrying the invoking member or user.

    DeferredCtx::user

    source

    The invoking user.

    DeferredCtx::wait_for_component

    source
    async fn DeferredCtx::wait_for_component(self : DeferredCtx, custom_id~ : String, timeout_ms? : Int) -> 
    ComponentCtx    ?

    Wait for the next component interaction with an exact custom id.

    FailureCtx

    source
    pub struct FailureCtx {
      // private fields
    }

    Context handed to the error policy when a handler fails.

    FailureCtx::interaction

    source

    The interaction payload associated with this failure. Event and service failures return None.

    FailureCtx::origin

    source
    fn FailureCtx::origin(self : FailureCtx) -> FailureOrigin

    What opened the modal: a component (with its host message) or a command.

    FailureCtx::phase

    source
    fn FailureCtx::phase(self : FailureCtx) -> ResponsePhase?

    How far the response lifecycle progressed before the failure, when an interaction was involved.

    FailureCtx::raw

    source
    fn FailureCtx::raw(self : FailureCtx) -> FailureRaw?

    Access the underlying interaction context. Event and service failures return None. Direct responses through this escape hatch may fail unless the response phase is checked first; normally use respond_error().

    FailureCtx::respond_error

    source
    async fn FailureCtx::respond_error(self : FailureCtx, content? : String, embeds? : Array[
    Embed    ], components? : Array[
    Component    ], files? : Array[
    FileUpload    ], allowed_mentions? : 
    AllowedMentions    , ephemeral? : Bool) -> Unit

    Send an error without violating Discord's one-initial-response rule. Event and service failures have no response target; those calls are sent to the warning hook instead of guessing a channel.

    FailureCtx::user

    source

    The user who invoked the failed interaction. Event and service failures return None.

    FailureOrigin

    source
    pub(all) enum FailureOrigin {
      Command(name~ : String)
      Autocomplete(name~ : String)
      Component(custom_id~ : String)
      Modal(custom_id~ : String)
      Event(kind~ : 
    EventKind    )
      Service(name~ : String)
    } derive(
    Debug    )

    The operation whose handler failed.

    FailureRaw

    source

    The underlying interaction context for a failure.

    Event and service failures have no raw context. Responding through one of these contexts without first checking the response phase may fail; prefer FailureCtx::respond_error() for ordinary error responses.

    ImmediateCtx

    source
    pub struct ImmediateCtx {
      // private fields
    }

    Read-only command context for handlers that return their initial response.

    ImmediateCtx::app

    source
    fn ImmediateCtx::app(self : ImmediateCtx) -> AppCtx

    The app-level services: the REST client and application id.

    ImmediateCtx::guild_id

    source

    The guild the interaction was invoked in, or None outside guilds. Use guild_scope() for flows that require a guild; this accessor is for maybe-guild flows where DMs are valid.

    ImmediateCtx::guild_scope

    source

    The validated guild invocation. In a DM this raises HandlerError::GuildOnly, which the error policy renders normally.

    ImmediateCtx::interaction

    source

    The full interaction payload.

    ImmediateCtx::raw

    source

    Escape hatch for advanced read-only inspection. Calling response methods on this raw value opts out of the immediate-handler response discipline.

    ImmediateCtx::scope

    source

    Guild or DM invocation scope, carrying the invoking member or user.

    ImmediateCtx::user

    source

    The invoking user.

    InitialResponse

    source
    pub struct InitialResponse {
      // private fields
    }

    A declarative initial message response returned by an immediate handler.

    InitialResponse::message

    source

    Construct an initial channel-message response.

    InteractionCtx

    source
    pub struct InteractionCtx {
      // private fields
    }

    Read-only context handed to interaction middleware, before any initial response has been sent.

    InteractionCtx::guild_id

    source

    The guild the interaction was invoked in, or None outside guilds. Use guild_scope() for flows that require a guild; this accessor is for maybe-guild flows where DMs are valid.

    InteractionCtx::guild_scope

    source

    The validated guild invocation. In a DM this raises HandlerError::GuildOnly, which the error policy renders normally.

    InteractionCtx::interaction

    source

    The full interaction payload.

    InteractionCtx::respond

    source
    async fn InteractionCtx::respond(self : InteractionCtx, message : String, ephemeral? : Bool) -> Unit

    Send the initial response from middleware, short-circuiting the handler.

    InteractionCtx::scope

    source

    Guild or DM invocation scope, carrying the invoking member or user.

    InteractionCtx::target

    source

    The routed command, component, or modal being invoked.

    InteractionCtx::user

    source

    The invoking user.

    InteractionEndpoint

    source
    pub struct InteractionEndpoint {
      // private fields
    }

    A gateway-free interaction dispatcher backed by a caller-owned task group.

    InteractionEndpoint::handle

    source
    async fn InteractionEndpoint::handle(self : InteractionEndpoint, body : Json, deadline_ms? : Int) -> Json?

    Decode and dispatch an interaction JSON body.

    Returns callback JSON only for Reply. Multipart files cannot be expressed by this thin JSON API; callers that accept uploads should use handle_interaction and inspect InteractionOutcome::Reply.files.

    InteractionEndpoint::handle_interaction

    source
    async fn InteractionEndpoint::handle_interaction(self : InteractionEndpoint, interaction : 
    Interaction    , deadline_ms? : Int) -> InteractionOutcome

    Dispatch one interaction and wait only for its initial response deadline. A timed-out handler remains attached to the app's task group and continues in the background.

    InteractionHandler

    source
    pub(all) enum InteractionHandler[A] {
      Immediate(async (ImmediateCtx, A) -> CommandReply)
      Deferred(ephemeral~ : Bool, async (DeferredCtx, A) -> Unit)
      Raw(async (
    CommandCtx    ) -> Unit)
    }

    Execution strategy for a typed application command.

    InteractionOutcome

    source
    pub(all) enum InteractionOutcome {
      Reply(response~ : 
    InteractionResponse    , files~ : Array[
    FileUpload    ]?)
      NoRoute
      NoResponse
      TimedOut
    } derive(
    Debug    )

    The result of dispatching one HTTP-delivered interaction.

    InteractionTarget

    source
    pub(all) enum InteractionTarget {
      Command(name~ : String)
      Component(custom_id~ : String)
      Modal(custom_id~ : String)
    } derive(
    Debug    )

    The routed target of an interaction entering the middleware chain. Autocomplete, gateway events, and services never pass through it.
    pub struct Modal[A] {
      // private fields
    }

    A typed modal definition. The field decoder is retained for the matching on_modal registration while show erases it into a ModalHandle.

    Modal::show

    source
    fn[A] Modal::show(self : Modal[A], state? : String, values? : Map[String, String]) -> ModalHandle raise ModalPrefillError

    Prepare a modal response, optionally appending opaque state after : and overriding text-input defaults by custom_id for this response only. Raises ModalPrefillError when an override key is unknown or does not name a text input.

    ModalDeferredCtx

    source
    pub struct ModalDeferredCtx {
      // private fields
    }

    Modal-submit context available after a deferred response.

    ModalDeferredCtx::app

    source

    The app-level services: the REST client and application id.

    ModalDeferredCtx::edit_original

    source

    Edit the original response after deferring.

    ModalDeferredCtx::followup

    source

    Send a followup message after the initial deferred response.

    ModalDeferredCtx::guild_id

    source

    The guild the interaction was invoked in, or None outside guilds. Use guild_scope() for flows that require a guild; this accessor is for maybe-guild flows where DMs are valid.

    ModalDeferredCtx::guild_scope

    source

    The validated guild invocation. In a DM this raises HandlerError::GuildOnly, which the error policy renders normally.

    ModalDeferredCtx::interaction

    source

    The full interaction payload.

    ModalDeferredCtx::origin

    source

    What opened the modal: a component (with its host message) or a command.

    ModalDeferredCtx::raw

    source

    Escape hatch for advanced inspection. Calling response methods on the raw value opts out of this wrapper's response discipline.

    ModalDeferredCtx::scope

    source

    Guild or DM invocation scope, carrying the invoking member or user.

    ModalDeferredCtx::state

    source
    fn ModalDeferredCtx::state(self : ModalDeferredCtx) -> String?

    The opaque state string passed to Modal::show, if any.

    ModalDeferredCtx::user

    source

    The invoking user.

    ModalField

    source
    pub struct ModalField[A] {
      // private fields
    }

    One typed input in a modal form.

    ModalField::map

    source
    fn[A, B] ModalField::map(self : ModalField[A], f : (A) -> B) -> ModalField[B]

    Transform a decoded modal field without changing its emitted component.

    ModalField::optional

    source
    fn[A] ModalField::optional(self : ModalField[A]) -> ModalField[A?]

    Make a modal field optional. Missing and empty submissions decode to None.

    ModalField::validate

    source
    fn[A] ModalField::validate(self : ModalField[A], check : (A) -> String?) -> ModalField[A]

    Validate a decoded field. Returning a message rejects the submission.

    ModalField::with_default

    source
    fn[A] ModalField::with_default(self : ModalField[A], value : A) -> ModalField[A]

    Use a default when a modal field is missing or empty.

    ModalFields

    source
    pub struct ModalFields[A] {
      // private fields
    }

    A composable collection of typed modal inputs.

    ModalFields::map

    source
    fn[A, B] ModalFields::map(self : ModalFields[A], f : (A) -> B) -> ModalFields[B]

    Transform the decoded value without changing the emitted components.

    ModalFields::map1

    source
    fn[A, Z] ModalFields::map1(a : ModalField[A], f : (A) -> Z) -> ModalFields[Z]

    Build a modal's field set from one field, mapping its decoded value into the handler's argument type.

    ModalFields::map2

    source
    fn[A, B, Z] ModalFields::map2(a : ModalField[A], b : ModalField[B], f : (A, B) -> Z) -> ModalFields[Z]

    Build a modal's field set from two fields, combining their decoded values with the final function argument.

    ModalFields::map3

    source
    fn[A, B, C, Z] ModalFields::map3(a : ModalField[A], b : ModalField[B], c : ModalField[C], f : (A, B, C) -> Z) -> ModalFields[Z]

    Build a modal's field set from three fields, combining their decoded values with the final function argument.

    ModalFields::map4

    source
    fn[A, B, C, D, Z] ModalFields::map4(a : ModalField[A], b : ModalField[B], c : ModalField[C], d : ModalField[D], f : (A, B, C, D) -> Z) -> ModalFields[Z]

    Build a modal's field set from four fields, combining their decoded values with the final function argument.

    ModalFields::map5

    source
    fn[A, B, C, D, E, Z] ModalFields::map5(a : ModalField[A], b : ModalField[B], c : ModalField[C], d : ModalField[D], e : ModalField[E], f : (A, B, C, D, E) -> Z) -> ModalFields[Z]

    Build a modal's field set from five fields, combining their decoded values with the final function argument.

    ModalFields::of

    source
    fn[A] ModalFields::of(field : ModalField[A]) -> ModalFields[A]

    Lift a single field into a ModalFields; combine further with zip and map, or use the mapN helpers directly.

    ModalFields::zip

    source
    fn[A, B] ModalFields::zip(self : ModalFields[A], other : ModalFields[B]) -> ModalFields[(A, B)]

    Concatenate two field sets and pair their decoded values.

    ModalHandle

    source
    pub struct ModalHandle {
      // private fields
    }

    A type-erased modal response ready to be returned by a command or component handler.

    ModalImmediateCtx

    source
    pub struct ModalImmediateCtx {
      // private fields
    }

    Read-only modal-submit context for handlers returning an initial message.

    ModalImmediateCtx::app

    source

    The app-level services: the REST client and application id.

    ModalImmediateCtx::guild_id

    source

    The guild the interaction was invoked in, or None outside guilds. Use guild_scope() for flows that require a guild; this accessor is for maybe-guild flows where DMs are valid.

    ModalImmediateCtx::guild_scope

    source

    The validated guild invocation. In a DM this raises HandlerError::GuildOnly, which the error policy renders normally.

    ModalImmediateCtx::interaction

    source

    The full interaction payload.

    ModalImmediateCtx::origin

    source

    What opened the modal: a component (with its host message) or a command.

    ModalImmediateCtx::raw

    source

    Escape hatch for advanced inspection. Calling response methods on the raw value opts out of this wrapper's response discipline.

    ModalImmediateCtx::scope

    source

    Guild or DM invocation scope, carrying the invoking member or user.

    ModalImmediateCtx::state

    source
    fn ModalImmediateCtx::state(self : ModalImmediateCtx) -> String?

    The opaque state string passed to Modal::show, if any.

    ModalImmediateCtx::user

    source

    The invoking user.

    ModalSubmitHandler

    source
    pub(all) enum ModalSubmitHandler[A] {
      Immediate(async (ModalImmediateCtx, A) -> InitialResponse)
      Deferred(ephemeral~ : Bool, async (ModalDeferredCtx, A) -> Unit)
      Raw(async (
    ModalCtx    ) -> Unit)
    }

    Execution strategy for a typed modal submission.

    RegisteredCommand

    source
    pub struct RegisteredCommand {
      // private fields
    }

    A type-erased command consumed by an App executor.

    RegisteredCommand::name

    source
    fn RegisteredCommand::name(self : RegisteredCommand) -> String

    The top-level command name used for routing.

    ResponsePhase

    source
    pub(all) enum ResponsePhase {
      BeforeInitial
      AfterDeferred
      AfterInitial
    } derive(Eq, 
    Debug    )

    The response state when an interaction handler failed.

    SlashChild

    source
    pub struct SlashChild {
      // private fields
    }

    A type-erased slash subcommand or subcommand group.

    commands_in_sync

    source

    Whether Discord's registered commands already match the declarations.

    Command (type, name) pairs must form the same set. For each command, comparison follows the declaration shape recursively, ignoring server-owned fields such as ids and versions while preserving option and choice order.

    dm_only

    source
    fn dm_only() -> ((CheckCtx) -> Bool raise HandlerError)

    Require a direct-message invocation.

    guild_only

    source
    fn guild_only() -> ((CheckCtx) -> Bool raise HandlerError)

    Require a guild invocation.

    message_command

    source

    Define a MESSAGE context-menu command.
    fn[A] modal(custom_id~ : String, title~ : String, fields~ : ModalFields[A]) -> Modal[A]

    Define a typed modal.

    test "construct and validate a typed modal" {
      let feedback = @app.modal(
        custom_id="feedback",
        title="Feedback",
        fields=@app.ModalFields::of(
          @app.text_field(custom_id="details", label="Details").optional(),
        ),
      )
      let app = @app.App(sync=Disabled)
      app.on_modal(feedback, Raw(_ => ()))
      app.validate()
      let _ : @app.ModalHandle = feedback.show(state="draft")
    }

    required_permissions

    source
    fn required_permissions(required : 
    Permissions    ) -> ((CheckCtx) -> Bool raise HandlerError)

    Require effective guild permissions supplied on the interaction member. Discord does not provide member permissions for DM invocations.

    select_field

    source
    fn select_field(custom_id~ : String, label~ : String, options~ : Array[
    SelectOption    ], description? : String, placeholder? : String, min_values? : Int, max_values? : Int) -> ModalField[Array[String]]

    Define a modern label-wrapped string select.

    slash

    source
    fn[A] slash(name~ : String, description~ : String, args~ : 
    Args    [A], handler~ : InteractionHandler[A], default_member_permissions? : 
    Permissions    , nsfw? : Bool, integration_types? : Array[
    ApplicationIntegrationType    ], contexts? : Array[
    InteractionContextType    ], name_localizations? : Map[String, String], description_localizations? : Map[String, String]) -> Command[A]

    Define a typed slash command.

    test "inspect a slash-command registration spec" {
      let command = @app.slash(
        name="echo",
        description="Echo text",
        args=@interaction.Args::of(
          @interaction.arg_string(name="text", description="Text to echo"),
        ),
        handler=Raw(_ => ()),
      )
      json_inspect(command.spec().to_json(), content={
        "name": "echo",
        "description": "Echo text",
        "options": [
          {
            "type": 3,
            "name": "text",
            "description": "Text to echo",
            "required": true,
          },
        ],
      })
    }

    slash_group

    source
    fn slash_group(name~ : String, description~ : String, children~ : Array[SlashChild], default_member_permissions? : 
    Permissions    , nsfw? : Bool, integration_types? : Array[
    ApplicationIntegrationType    ], contexts? : Array[
    InteractionContextType    ], name_localizations? : Map[String, String], description_localizations? : Map[String, String]) -> Command[Unit]

    Define a slash command whose children dispatch by submitted option path.

    subcommand

    source
    fn[A] subcommand(name~ : String, description~ : String, args~ : 
    Args    [A], handler~ : InteractionHandler[A], name_localizations? : Map[String, String], description_localizations? : Map[String, String]) -> SlashChild

    Define a typed slash subcommand.

    subcommand_group

    source
    fn subcommand_group(name~ : String, description~ : String, children~ : Array[SlashChild], name_localizations? : Map[String, String], description_localizations? : Map[String, String]) -> SlashChild

    Define a slash subcommand group. Nested groups are retained for validation and rejected by App::validate, never by panic or abort here.

    text_field

    source
    fn text_field(custom_id~ : String, label~ : String, style? : 
    TextInputStyle    , description? : String, placeholder? : String, min_length? : Int, max_length? : Int, value? : String) -> ModalField[String]

    Define a modern label-wrapped text input. value is its static prefill; Modal::show(values=...) can override it for one response.

    user_command

    source

    Define a USER context-menu command.

    test "inspect context-menu command kinds" {
      let user = @app.user_command(name="Inspect user", handler=Raw(_ => ()))
      let message = @app.message_command(
        name="Inspect message",
        handler=Raw(_ => ()),
      )
      json_inspect(user.spec().to_json(), content={
        "name": "Inspect user",
        "description": "",
        "type": 2,
      })
      json_inspect(message.spec().to_json(), content={
        "name": "Inspect message",
        "description": "",
        "type": 3,
      })
    }

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io