🥮 mooncakes.io

    gaato/discord/framework does not have a README file

    InteractionContextError

    source
    pub(all) suberror InteractionContextError {
      MissingInvoker
      MissingGuildMemberUser
      MissingGuildId
      MissingComponentMessage
    } derive(
    Debug    )

    A malformed interaction that cannot satisfy the guarantees exposed by a typed handler context.

    ResponseGateError

    source
    pub(all) suberror ResponseGateError {
      AlreadyResponded
      Expired
      InvalidCallback(kind~ : 
    InteractionType    , typ~ : 
    InteractionResponseType    )
    } derive(
    Debug    )

    An error raised when an interaction callback cannot be accepted.

    AutocompleteCtx

    source

    Context handed to an autocomplete handler.

    AutocompleteCtx::suggest

    source

    Send autocomplete suggestions. Choices beyond the first 25 are truncated.

    CapturedResponse

    source

    A callback plus any multipart files captured by an in-memory gate.

    CommandCtx

    source

    Context handed to a slash / context-menu command handler.

    CommandCtx::defer_response

    source
    async fn CommandCtx::defer_response(self : CommandCtx, ephemeral? : Bool) -> Unit

    Acknowledge now and reply later via edit_response / followup.

    CommandCtx::delete_followup

    source

    Delete a followup message for this command interaction.

    CommandCtx::delete_response

    source
    async fn CommandCtx::delete_response(self : CommandCtx) -> Unit

    Delete the original response to this command interaction.

    CommandCtx::edit_followup

    source

    Edit a followup message for this command interaction.

    CommandCtx::edit_response

    source

    Edit the original response (typically after defer).

    CommandCtx::followup

    source

    Send a followup message after the initial response.

    CommandCtx::get_followup

    source

    Fetch a followup message for this command interaction.

    CommandCtx::guild_scope

    source
    fn CommandCtx::guild_scope(self : CommandCtx) -> GuildInvocation?

    The validated guild invocation, or None when invoked in a DM.

    CommandCtx::model

    source

    Decode the submitted options into a typed CommandModel.

    CommandCtx::original_response

    source
    async fn CommandCtx::original_response(self : CommandCtx) -> 
    Message

    Fetch the original response to this command interaction.

    CommandCtx::respond

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

    Send the initial "channel message with source" response.

    CommandCtx::response_state

    source
    fn CommandCtx::response_state(self : CommandCtx) -> ResponseState

    The current state of this interaction's initial callback.

    CommandCtx::scope

    source

    Whether the command was invoked in a guild or a DM.

    CommandCtx::show_modal

    source
    async fn CommandCtx::show_modal(self : CommandCtx, custom_id~ : String, title~ : String, components~ : Array[
    Component    ]) -> Unit

    Display a modal as the initial command response.

    CommandCtx::target_message

    source

    The resolved target of a MESSAGE context-menu command, or None when this is not a message command or its target is unavailable.

    CommandCtx::target_user

    source
    fn CommandCtx::target_user(self : CommandCtx) -> TargetUser?

    The resolved target of a USER context-menu command, or None when this is not a user command or its target is unavailable.

    CommandCtx::user

    source

    The invoking user.

    ComponentCtx

    source

    Context handed to a message-component (button / select) handler.

    ComponentCtx::defer_response

    source
    async fn ComponentCtx::defer_response(self : ComponentCtx, ephemeral? : Bool) -> Unit

    Acknowledge now and send a message later through webhook methods.

    ComponentCtx::defer_update

    source
    async fn ComponentCtx::defer_update(self : ComponentCtx) -> Unit

    Acknowledge without any visible change (edit later if needed).

    ComponentCtx::delete_followup

    source

    Delete a followup message for this component interaction.

    ComponentCtx::delete_response

    source
    async fn ComponentCtx::delete_response(self : ComponentCtx) -> Unit

    Delete the original response to this component interaction.

    ComponentCtx::edit_followup

    source

    Edit a followup message for this component interaction.

    ComponentCtx::edit_response

    source

    Edit the original interaction response after deferring.

    ComponentCtx::followup

    source

    Send a component-interaction followup message.

    ComponentCtx::get_followup

    source

    Fetch a followup message for this component interaction.

    ComponentCtx::guild_scope

    source
    fn ComponentCtx::guild_scope(self : ComponentCtx) -> GuildInvocation?

    The validated guild invocation, or None when invoked in a DM.

    ComponentCtx::message

    source

    The message to which the component was attached.

    ComponentCtx::original_response

    source
    async fn ComponentCtx::original_response(self : ComponentCtx) -> 
    Message

    Fetch the original response to this component interaction.

    ComponentCtx::respond

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

    Send a new "channel message with source" response.

    ComponentCtx::response_state

    source
    fn ComponentCtx::response_state(self : ComponentCtx) -> ResponseState

    The current state of this interaction's initial callback.

    ComponentCtx::scope

    source

    Whether the component was invoked in a guild or a DM.

    ComponentCtx::show_modal

    source
    async fn ComponentCtx::show_modal(self : ComponentCtx, custom_id~ : String, title~ : String, components~ : Array[
    Component    ]) -> Unit

    Display a modal as the initial component response.

    ComponentCtx::update_message

    source
    async fn ComponentCtx::update_message(self : ComponentCtx, content? : String, embeds? : Array[
    Embed    ], components? : Array[
    Component    ], allowed_mentions? : 
    AllowedMentions    ) -> Unit

    Edit the message the component is attached to.

    ComponentCtx::user

    source

    The invoking user.

    Framework

    source
    pub struct Framework {
      // private fields
    }

    Routes incoming interactions to declared command / component / modal handlers, and can register the declared commands with Discord.

    Registration methods return self for chaining. Feed every InteractionCreate gateway event to process.

    Framework::Framework

    source

    Create an empty interaction router bound to a REST client and application id. Most bots configure routes through @app.App and let an executor call App::attach instead of registering here directly.

    Framework::autocomplete

    source
    fn Framework::autocomplete(self : Framework, command_name : String, handler : async (AutocompleteCtx) -> Unit) -> Framework

    Register an autocomplete handler for a command name.

    Framework::command

    source
    fn Framework::command(self : Framework, spec : 
    CommandSpec    , handler : async (CommandCtx) -> Unit) -> Framework

    Register a command: spec describes it to Discord, handler runs when it is invoked. Routing is by command type and top-level command name; subcommand routing happens inside the handler via ctx.options.path().

    Framework::command_specs

    source
    fn Framework::command_specs(self : Framework) -> Json

    The registration payload for every declared command, as sent to the bulk-overwrite endpoints.

    Framework::component

    source
    fn Framework::component(self : Framework, prefix : String, handler : async (ComponentCtx) -> Unit) -> Framework

    Register a component handler for custom ids starting with prefix. Longer prefixes win; equally long prefixes retain registration order. Exact-id waiters take precedence over all registered handlers. Empty and duplicate routes are accepted here; validation is App's job.

    Framework::component_id

    source
    fn Framework::component_id(self : Framework, id : String, handler : async (ComponentCtx) -> Unit) -> Framework

    Register a component handler matching id or id followed by : and state. Ranked by the length of id + ":"; ties retain registration order. Exact-id waiters take precedence. Empty, duplicate, and malformed ids are accepted here; validation is App's job.

    Framework::modal

    source
    fn Framework::modal(self : Framework, prefix : String, handler : async (ModalCtx) -> Unit) -> Framework

    Register a modal-submit handler for custom ids starting with prefix. Longer prefixes win; equally long prefixes retain registration order. Empty and duplicate routes are accepted here; validation is App's job.

    Framework::modal_id

    source
    fn Framework::modal_id(self : Framework, id : String, handler : async (ModalCtx) -> Unit) -> Framework

    Register a modal handler matching id or id followed by : and state. Ranked by the length of id + ":"; ties retain registration order. Empty, duplicate, and malformed ids are accepted here; validation is App's job.

    Framework::on_error

    source
    fn Framework::on_error(self : Framework, hook : async (String, Error) -> Unit) -> Framework

    Install an error hook. When set, handler errors are passed to it (with a kind:name label) instead of propagating out of process.

    Framework::process

    source
    async fn Framework::process(self : Framework, interaction : 
    Interaction    ) -> Bool

    Route one interaction. Returns true when a handler (or waiter) consumed it, false when nothing matched. Handler errors propagate unless an on_error hook is installed.

    Framework::process_with

    source
    async fn Framework::process_with(self : Framework, interaction : 
    Interaction    , gate~ : ResponseGate) -> Bool

    Route one interaction through a caller-provided initial-response gate.

    Framework::sync_global

    source
    async fn Framework::sync_global(self : Framework, unowned? : UnownedCommands) -> ScopeSyncReport

    Synchronize global commands, preserving entry points and reporting changes.

    Framework::sync_guild

    source

    Synchronize one guild's commands and report changes.

    Framework::wait_for_component

    source
    async fn Framework::wait_for_component(self : Framework, custom_id~ : String, user? : 
    Id    [
    UserMarker    ], timeout_ms? : Int) -> ComponentCtx?

    Wait for the next component interaction whose custom id matches exactly and whose invoking user matches user, when provided. Returns None on timeout. Waiters win over registered component handlers, which makes multi-step flows (confirm buttons, pagination) straightforward inside one handler.

    GuildInvocation

    source

    Proof that an interaction was invoked in a guild: the guild id and the invoking member, both validated when the context was built.

    GuildInvocation::user

    source

    The user who invoked this interaction.

    InvocationScope

    source
    pub(all) enum InvocationScope {
      Guild(GuildInvocation)
      Dm(
    User    )
    } derive(
    Debug    )

    The context in which an interaction was invoked.

    ModalCtx

    source

    Context handed to a modal-submit handler.

    ModalCtx::defer_response

    source
    async fn ModalCtx::defer_response(self : ModalCtx, ephemeral? : Bool) -> Unit

    Acknowledge now and reply later via a followup.

    ModalCtx::delete_followup

    source
    async fn ModalCtx::delete_followup(self : ModalCtx, message_id : 
    Id    [
    MessageMarker    ]) -> Unit

    Delete a followup message for this modal interaction.

    ModalCtx::delete_response

    source
    async fn ModalCtx::delete_response(self : ModalCtx) -> Unit

    Delete the original response to this modal interaction.

    ModalCtx::edit_followup

    source

    Edit a followup message for this modal interaction.

    ModalCtx::edit_response

    source

    Edit the original modal interaction response after deferring.

    ModalCtx::followup

    source

    Send a modal-interaction followup message.

    ModalCtx::get_followup

    source

    Fetch a followup message for this modal interaction.

    ModalCtx::guild_scope

    source
    fn ModalCtx::guild_scope(self : ModalCtx) -> GuildInvocation?

    The validated guild invocation, or None when invoked in a DM.

    ModalCtx::origin

    source
    fn ModalCtx::origin(self : ModalCtx) -> ModalOrigin

    Whether the modal was opened from a component or from a command.

    ModalCtx::original_response

    source
    async fn ModalCtx::original_response(self : ModalCtx) -> 
    Message

    Fetch the original response to this modal interaction.

    ModalCtx::respond

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

    Send a "channel message with source" response to the modal.

    ModalCtx::response_state

    source
    fn ModalCtx::response_state(self : ModalCtx) -> ResponseState

    The current state of this interaction's initial callback.

    ModalCtx::scope

    source
    fn ModalCtx::scope(self : ModalCtx) -> InvocationScope

    Whether the modal was submitted in a guild or a DM.

    ModalCtx::text_value

    source
    fn ModalCtx::text_value(self : ModalCtx, custom_id : String) -> String?

    The submitted value of the text input with the given custom id.

    ModalCtx::user

    source

    The invoking user.

    ModalOrigin

    source
    pub(all) enum ModalOrigin {
      FromComponent(
    Message    )
      FromCommand
    } derive(
    Debug    )

    The interaction that opened a submitted modal.

    ResponseCapture

    source
    pub struct ResponseCapture {
      // private fields
    }

    The receiving side of a capture gate.

    ResponseCapture::get

    source

    Wait for and remove the captured callback.

    ResponseCapture::try_get

    source
    fn ResponseCapture::try_get(self : ResponseCapture) -> CapturedResponse? raise

    Remove the captured callback without waiting, if one is available.

    ResponseGate

    source
    pub struct ResponseGate {
      // private fields
    }

    A single-use interaction callback gate.

    ResponseGate::ResponseGate

    source

    Construct a gate around an injected callback sink. rejected identifies definitive refusals that leave the callback unused. Cancellation always leaves delivery unconfirmed, regardless of the classifier.

    ResponseGate::capture

    source

    Construct an in-memory gate and a receiver for the first callback value.

    ResponseGate::expire

    source
    fn ResponseGate::expire(self : ResponseGate) -> Unit

    Close an unused callback window. Other states remain unchanged.

    test "expire an unused callback window" {
      let gate = @framework.ResponseGate(ApplicationCommand, (_, _) => ())
      assert_eq(gate.state(), Pending)
      gate.expire()
      assert_eq(gate.state(), Expired)
      assert_true(gate.responded())
    }

    ResponseGate::responded

    source
    fn ResponseGate::responded(self : ResponseGate) -> Bool

    Whether the initial callback is no longer pending, including expiry.

    ResponseGate::rest

    source

    Construct a gate that delivers its callback through Discord's REST API.

    ResponseGate::send

    source

    Validate and deliver the one allowed initial interaction callback.

    ResponseGate::state

    source

    The current state of this interaction's initial callback.

    ResponseState

    source

    What has happened to an interaction's single initial callback.

    ScopeSyncReport

    source
    pub(all) struct ScopeSyncReport {
      guild_id : 
    Id    [
    GuildMarker    ]?
      created : Array[String]
      updated : Array[String]
      deleted : Array[String]
      unchanged : Array[String]
      preserved : Array[String]
      overwritten : Bool
    } derive(
    Debug    )

    Changes in one scope. Slash commands use plain names; other commands use <type int>:<name>. None identifies the global scope.

    TargetUser

    source
    pub(all) struct TargetUser {
      user : 
    User
      member : 
    GuildMember    ?
    }

    The resolved target of a USER context-menu command.

    UnownedCommands

    source
    pub(all) enum UnownedCommands {
      Delete
      Keep
    } derive(Eq, 
    Debug    )

    What to do with undeclared remote commands. Entry points are always kept.

    plan_command_sync

    source

    Plan a bulk overwrite from raw list-endpoint objects without mutating them. Entry points and, under Keep, other undeclared commands retain their ids and unknown fields. A matching catalog needs no PUT; duplicate remote keys force one. The payload follows declaration order, then preserved remote order.

    test {
      let (payload, report) = @framework.plan_command_sync([], [], unowned=Keep)
      assert_true(payload is None)
      assert_false(report.overwritten)
    }

    sync_command_scope

    source

    Fetch raw commands with localizations, plan changes, and overwrite only when needed. Failures propagate without returning a successful report.

    Source Files

    Powered by MoonBit

    Site sourceReport issuePackagesBuild queueSkillsStatistics

    © 2026 mooncakes.io