@neontechspace/fluxerly 1000.0.0-nightly.12

package/dist/api/default/direct-messages.d.ts

@@ -0,0 +1,111 @@
+import type { DirectMessageChannel, DirectMessageGroupEdit, DirectMessageLatestMessages, UserOperationFailure, DefaultUserOperationOptions } from "#sdk/users";
+import type { ResultAsync } from "neverthrow";
+import type { CancelledError, ConfigurationError } from "#sdk/errors";
+import type { SendError } from "#sdk/message-errors";
+import type { Message, MessageCore, ReplyInput, DefaultSendOptions } from "#sdk/messages";
+/**
+ * Open and manage private one-to-one or group conversations with the bot's credentials.
+ * Use directMessages.send to open a conversation and send in one call, or the messages namespace when the private channel ID is known.
+ * No gateway connection is required.
+ * HTTP calls start immediately with the client's shared default deadline (rest.defaultTimeoutMs, 30,000 ms unless configured) and eligible read retries.
+ * Writes retry only confirmed rate-limit rejection, never an uncertain outcome.
+ * Abort waits for cleanup and returns CancelledError.
+ * Unexpected failures reject with SdkDefect
+ *
+ * @category Users and DMs
+ */
+export interface DirectMessages<M extends MessageCore = Message> {
+    /**
+     * Open or reopen a one-to-one conversation with a user, then send a message.
+     * A plain string sends only that text, as shorthand for `{ content }`.
+     * The whole operation uses one deadline, and mentions are disabled by default.
+     * Message metadata and data bytes are prepared before opening the conversation.
+     * File and stream sources are captured, not copied, and read later when uploads start, using messages.send's size, upload-budget and cleanup rules.
+     * An inline multipart 429 does not replay file or stream sources.
+     * MessageError with outcome notDispatched does not mean opening the conversation was undone.
+     * A send with an unknown outcome is never repeated automatically.
+     * The opened conversation is cached under the same conditions as open.
+     * Reply references are not accepted here.
+     * Use messages.reply with an existing channel and message reference
+     *
+     * @example
+     * ```ts
+     * import type { Client } from "@neontechspace/fluxerly"
+     * export async function notifyUserExample(client: Client, userId: string) {
+     *     const user = await client.users.fetch(userId)
+     *     if (user.isErr()) return user
+     *     return client.directMessages.send(user.value.id, { content: `Hello ${user.value.displayName ?? user.value.username}` })
+     * }
+     * ```
+     */
+    send(userId: string, input: ReplyInput | string, options?: DefaultSendOptions): ResultAsync<M, SendError | CancelledError | ConfigurationError>;
+    /**
+     * Look up a private channel in the optional cache using its decimal ID, without a request.
+     * A hit may be stale and becomes more recently used without extending its age.
+     * A miss produces undefined.
+     * An invalid ID is misuse: The default API throws UserOperationError with reason input and the native API dies with it.
+     * A closing or closed client has no cache, so the result is undefined
+     *
+     * @remarks
+     * Returns the value synchronously.
+     * Unexpected failures throw SdkDefect
+     */
+    get(id: string): DirectMessageChannel | undefined;
+    /**
+     * Open or reopen a one-to-one conversation with the selected user.
+     * The result is a private channel, not proof a message can be delivered.
+     * Privacy checks can still prevent sending after opening succeeds.
+     * With the direct-message cache enabled, the channel ID is unknown until the response arrives, so some concurrent direct-message cache changes keep the result out of the cache.
+     * Examples are a directMessages.fetch call and a direct-message update event
+     */
+    open(userId: string, options?: DefaultUserOperationOptions): ResultAsync<DirectMessageChannel, UserOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch a private channel by decimal ID.
+     * A community-channel response is rejected as invalid.
+     * With the direct-message cache enabled, a concurrent fetch of another private channel ID does not keep this result from being stored, unless more than 256 private channel IDs are in flight at once
+     */
+    fetch(id: string, options?: DefaultUserOperationOptions): ResultAsync<DirectMessageChannel, UserOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch this bot's currently open one-to-one and group conversations.
+     * Personal notes are excluded.
+     * The list is neither an atomic snapshot nor complete message history.
+     * Enabled cache replacement is skipped when a later targeted request or channel observation conflicts
+     */
+    fetchAll(options?: DefaultUserOperationOptions): ResultAsync<readonly DirectMessageChannel[], UserOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch the latest messages for 1–100 selected, distinct private channel IDs through Fluxer's batch endpoint.
+     * IDs are copied by index when execution starts.
+     * This does not enumerate conversations or fill a cache.
+     * A null entry does not prove an empty channel or denied access.
+     * The omittedChannelIds field separately lists requested IDs that Fluxer did not return.
+     * Do not treat omission as null, an empty channel or denied access.
+     * The batch uses POST and is not retried after a dispatched failure with an unknown outcome, even though it reads data
+     */
+    fetchLatestMessages(channelIds: readonly string[], options?: DefaultUserOperationOptions): ResultAsync<DirectMessageLatestMessages<M>, UserOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Change supplied settings of an existing group conversation.
+     * A null name clears it, and omitted fields remain unchanged.
+     * Fluxer enforces member and owner permissions.
+     * A failed response does not guarantee rollback.
+     * Enabled cache invalidation normally stays scoped to this conversation.
+     * A cache-wide conflict check can also prevent older in-flight results from being stored
+     */
+    editGroup(id: string, input: DirectMessageGroupEdit, options?: DefaultUserOperationOptions): ResultAsync<DirectMessageChannel, UserOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Close a one-to-one conversation for this bot, or leave a group conversation.
+     * Another recipient's conversation is not erased.
+     * If the group owner leaves, ownership may transfer.
+     * Enabled cache invalidation normally stays scoped to this conversation.
+     * A cache-wide conflict check can also prevent older in-flight results from being stored
+     */
+    close(id: string, options?: DefaultUserOperationOptions): ResultAsync<void, UserOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Remove a group recipient as owner, or remove the bot itself.
+     * This does not request deletion of that user's messages.
+     * If the last recipient leaves, Fluxer deletes the group.
+     * Enabled cache invalidation normally stays scoped to this conversation.
+     * A cache-wide conflict check can also prevent older in-flight results from being stored
+     */
+    removeRecipient(id: string, userId: string, options?: DefaultUserOperationOptions): ResultAsync<void, UserOperationFailure | CancelledError | ConfigurationError>;
+}
+//# sourceMappingURL=direct-messages.d.ts.map

package/dist/api/default/direct-messages.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"direct-messages.d.ts","sourceRoot":"","sources":["../../../src/api/default/direct-messages.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,oBAAoB,EACpB,sBAAsB,EACtB,2BAA2B,EAC3B,oBAAoB,EACpB,2BAA2B,EAC9B,MAAM,YAAY,CAAA;AACnB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AACrE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,UAAU,EAAE,kBAAkB,EAAE,MAAM,eAAe,CAAA;AAEzF;;;;;;;;;;GAUG;AACH,MAAM,WAAW,cAAc,CAAC,CAAC,SAAS,WAAW,GAAG,OAAO;IAC3D;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,IAAI,CACA,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,UAAU,GAAG,MAAM,EAC1B,OAAO,CAAC,EAAE,kBAAkB,GAC7B,WAAW,CAAC,CAAC,EAAE,SAAS,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAClE;;;;;;;;;;OAUG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,oBAAoB,GAAG,SAAS,CAAA;IACjD;;;;;;OAMG;IACH,IAAI,CACA,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,2BAA2B,GACtC,WAAW,CAAC,oBAAoB,EAAE,oBAAoB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAChG;;;;OAIG;IACH,KAAK,CACD,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,2BAA2B,GACtC,WAAW,CAAC,oBAAoB,EAAE,oBAAoB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAChG;;;;;OAKG;IACH,QAAQ,CACJ,OAAO,CAAC,EAAE,2BAA2B,GACtC,WAAW,CAAC,SAAS,oBAAoB,EAAE,EAAE,oBAAoB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAC3G;;;;;;;;OAQG;IACH,mBAAmB,CACf,UAAU,EAAE,SAAS,MAAM,EAAE,EAC7B,OAAO,CAAC,EAAE,2BAA2B,GACtC,WAAW,CAAC,2BAA2B,CAAC,CAAC,CAAC,EAAE,oBAAoB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAC1G;;;;;;;OAOG;IACH,SAAS,CACL,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,sBAAsB,EAC7B,OAAO,CAAC,EAAE,2BAA2B,GACtC,WAAW,CAAC,oBAAoB,EAAE,oBAAoB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAChG;;;;;;OAMG;IACH,KAAK,CACD,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,2BAA2B,GACtC,WAAW,CAAC,IAAI,EAAE,oBAAoB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAChF;;;;;;OAMG;IACH,eAAe,CACX,EAAE,EAAE,MAAM,EACV,MAAM,EAAE,MAAM,EACd,OAAO,CAAC,EAAE,2BAA2B,GACtC,WAAW,CAAC,IAAI,EAAE,oBAAoB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;CACnF"}

package/dist/api/default/direct-messages.js

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

package/dist/api/default/direct-messages.js.map

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

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

@@ -0,0 +1,76 @@
+import type { DiscoveryApplication, DiscoveryApplicationInput, DiscoveryApplicationEdit, DiscoveryCategory, DiscoverySearchPage, DiscoverySearchQuery, DiscoveryStatus } from "#sdk/discovery";
+import type { ResultAsync } from "neverthrow";
+import type { GuildOperationFailure, DefaultGuildOperationOptions } from "#sdk/guilds";
+import type { CancelledError, ConfigurationError } from "#sdk/errors";
+/**
+ * Search Fluxer's public community directory and manage a community's directory application.
+ * This is separate from finding the instance's API and gateway endpoints.
+ * Calls start immediately without a gateway connection or directory cache.
+ * The default deadline, rest.defaultTimeoutMs (30,000 ms unless configured), includes request-capacity and rate-limit waits.
+ * Eligible GET failures retry at most twice
+ *
+ * Writes retry only confirmed HTTP 429 rejection.
+ * Input, HTTP and malformed-response failures return GuildOperationError.
+ * Client closure returns ClientClosedError.
+ * Abort waits for cleanup and returns CancelledError.
+ * Unexpected failures reject with SdkDefect.
+ * Application writes may publish or remove a listing and invalidate cached guild data.
+ * No eligibility check, approval, resubmission or joining is performed automatically.
+ * A failed write does not guarantee rollback
+ *
+ * @category Guilds and members
+ */
+export interface Discovery {
+    /**
+     * Fetch one page from the current public community directory.
+     * The limit option defaults to 24, and offset defaults to 0.
+     * Pages can change between reads, so offset-based scans are not a stable snapshot.
+     * This neither joins a community nor caches its directory entry, and needs no gateway connection.
+     * Eligible read failures are retried as described for this namespace
+     */
+    search(query?: DiscoverySearchQuery, options?: DefaultGuildOperationOptions): ResultAsync<DiscoverySearchPage, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch a community's current directory eligibility and application state.
+     * Use a decimal guild ID with ManageGuild permission.
+     * A result with eligible false can mean discovery is disabled or the member threshold is unmet, without distinguishing them.
+     * Eligibility can change before application.
+     * Reviewed or removed applications include their available reasons
+     */
+    fetchStatus(guildId: string, options?: DefaultGuildOperationOptions): ResultAsync<DiscoveryStatus, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch directory category IDs and Fluxer's category labels in provider order.
+     * This requires an authenticated client, not membership of a particular community or ManageGuild.
+     * No category copy is kept
+     */
+    fetchCategories(options?: DefaultGuildOperationOptions): ResultAsync<readonly DiscoveryCategory[], GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Submit a community's application to the public directory.
+     * ManageGuild, enabled discovery and current Fluxer eligibility are required.
+     * An existing pending or approved application fails remotely.
+     * Eligible verified or partnered communities may be approved immediately.
+     * The returned stored application does not guarantee approval or search visibility.
+     * An unknown outcome may already have submitted or published the listing.
+     * Check fetchStatus before trying again
+     */
+    apply(guildId: string, input: DiscoveryApplicationInput, options?: DefaultGuildOperationOptions): ResultAsync<DiscoveryApplication, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Change supplied fields of a pending or approved directory application.
+     * ManageGuild and enabled discovery are required.
+     * At least one field must be supplied, and omitted fields remain unchanged.
+     * Tags use the input type's normalization and replacement rules.
+     * No old application is fetched or merged automatically.
+     * Updates to an approved listing can become public, while search-index updates can lag or partially fail
+     */
+    edit(guildId: string, input: DiscoveryApplicationEdit, options?: DefaultGuildOperationOptions): ResultAsync<DiscoveryApplication, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Withdraw a pending application or remove an approved directory listing.
+     * ManageGuild and enabled discovery are required.
+     * HTTP 204 succeeds with no value.
+     * A missing application is a remote error, not an assumed successful no-op.
+     * Fluxer removes the application record and may separately remove its feature or search entry.
+     * The community and its members remain, and the prior application is not restored.
+     * An unknown or partial outcome needs remote inspection and may require operator recovery, not blind replay
+     */
+    withdraw(guildId: string, options?: DefaultGuildOperationOptions): ResultAsync<void, GuildOperationFailure | CancelledError | ConfigurationError>;
+}
+//# sourceMappingURL=discovery.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/api/default/discovery.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,oBAAoB,EACpB,yBAAyB,EACzB,wBAAwB,EACxB,iBAAiB,EACjB,mBAAmB,EACnB,oBAAoB,EACpB,eAAe,EAClB,MAAM,gBAAgB,CAAA;AACvB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,MAAM,aAAa,CAAA;AACtF,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErE;;;;;;;;;;;;;;;;;GAiBG;AACH,MAAM,WAAW,SAAS;IACtB;;;;;;OAMG;IACH,MAAM,CACF,KAAK,CAAC,EAAE,oBAAoB,EAC5B,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,mBAAmB,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAChG;;;;;;OAMG;IACH,WAAW,CACP,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,eAAe,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAC5F;;;;OAIG;IACH,eAAe,CACX,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,SAAS,iBAAiB,EAAE,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACzG;;;;;;;;OAQG;IACH,KAAK,CACD,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,yBAAyB,EAChC,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,oBAAoB,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACjG;;;;;;;OAOG;IACH,IAAI,CACA,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,wBAAwB,EAC/B,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,oBAAoB,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACjG;;;;;;;;OAQG;IACH,QAAQ,CACJ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,IAAI,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;CACpF"}

package/dist/api/default/discovery.js

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

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

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

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

@@ -0,0 +1,88 @@
+import type { GuildEmoji, ExpressionReference, ExpressionMetadata, ExpressionSourceGuild, EmojiCreate, EmojiEdit, ExpressionBatch, DefaultExpressionDeleteOptions } from "#sdk/expressions";
+import type { ResultAsync } from "neverthrow";
+import type { GuildOperationFailure, DefaultGuildOperationOptions, DefaultModerationOptions } from "#sdk/guilds";
+import type { CancelledError, ConfigurationError } from "#sdk/errors";
+/**
+ * Create, list, copy, rename and delete community emoji.
+ * Use get for an optional local cache lookup, or fetchAll, fetchMetadata and fetchSource for remote reads.
+ * Shared guild request limits, deadlines and read retries apply.
+ * Writes retry only confirmed HTTP 429 rejections.
+ * Input, permission, not-found and malformed-response errors are not retried.
+ * A lost response can leave a write applied.
+ * Results are frozen snapshots, not gateway acknowledgement
+ *
+ * Expected failures return GuildOperationError or ClientClosedError.
+ * Abort returns CancelledError after cleanup.
+ * Unexpected failures reject with SdkDefect
+ *
+ * @category Emoji and stickers
+ */
+export interface Emojis {
+    /**
+     * Look up cached emoji metadata using decimal guildId and id, without an HTTP request.
+     * The result is undefined when caching is disabled or the entry is absent, expired or invalidated by a conflicting change.
+     * A hit becomes more recently used without extending expiry.
+     * An invalid ID is misuse: The default API throws GuildOperationError with reason input and the native API dies with it.
+     * A closing or closed client has no cache, so the result is undefined
+     *
+     * @remarks
+     * Returns the value synchronously.
+     * Unexpected failures throw SdkDefect
+     */
+    get(target: ExpressionReference): GuildEmoji | undefined;
+    /**
+     * Fetch a community's emoji list in Fluxer's order, without pagination.
+     * The list can change after the response and is not an ongoing completeness guarantee.
+     * An enabled metadata cache can retain results, but not image bytes or creator accounts
+     */
+    fetchAll(guildId: string, options?: DefaultGuildOperationOptions): ResultAsync<readonly GuildEmoji[], GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch minimal emoji metadata by decimal ID, without requiring source-community membership.
+     * This read does not populate the cache
+     */
+    fetchMetadata(id: string, options?: DefaultGuildOperationOptions): ResultAsync<ExpressionMetadata, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Fetch the public presentation of the community that owns a custom emoji with this decimal ID: Its ID, name, icon hash and badges.
+     * Fluxer answers when the source community is discoverable or the bot is a member of it.
+     * A private source community the bot is not in, an unavailable community or an unknown emoji fails with GuildOperationError
+     * whose apiError.code is unknownResource, without revealing which case applies.
+     * This read does not populate the cache, and the result does not update when the community changes
+     */
+    fetchSource(id: string, options?: DefaultGuildOperationOptions): ResultAsync<ExpressionSourceGuild, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Upload one community emoji and return its metadata.
+     * Inputs are copied when execution starts.
+     * No image URL is fetched automatically.
+     * Fluxer checks image format, dimensions, permissions and capacity.
+     * A write with an unknown outcome is not replayed
+     */
+    create(guildId: string, input: EmojiCreate, options?: DefaultModerationOptions): ResultAsync<GuildEmoji, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Upload 1–50 community emojis in one batch and return separate successes and failures.
+     * The input array is copied by index, then its entries are copied when execution starts.
+     * Some uploads can succeed while others fail.
+     * No rollback or automatic chunking is performed.
+     * Failures named by duplicate emoji names cannot be matched reliably to input positions.
+     * After an unknown outcome, fetch fresh remote data rather than blindly replaying the batch
+     */
+    createMany(guildId: string, input: readonly EmojiCreate[], options?: DefaultModerationOptions): ResultAsync<ExpressionBatch<GuildEmoji>, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Copy an emoji into a community by its source ID, using Fluxer's server-side copy.
+     * Source metadata is preserved.
+     * Fluxer enforces source copying restrictions
+     */
+    clone(guildId: string, sourceId: string, options?: DefaultModerationOptions): ResultAsync<GuildEmoji, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Rename a community emoji without changing its image or fetching its old metadata first
+     */
+    edit(target: ExpressionReference, input: EmojiEdit, options?: DefaultModerationOptions): ResultAsync<GuildEmoji, GuildOperationFailure | CancelledError | ConfigurationError>;
+    /**
+     * Remove an emoji, succeeding with no value after HTTP 204.
+     * Retained metadata is invalidated.
+     * A missing target is an error, not proof of an earlier deletion.
+     * The purge option defaults to false.
+     * Setting it to true also queues irreversible media removal, subject to Fluxer's restrictions
+     */
+    delete(target: ExpressionReference, options?: DefaultExpressionDeleteOptions): ResultAsync<void, GuildOperationFailure | CancelledError | ConfigurationError>;
+}
+//# sourceMappingURL=emojis.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"emojis.d.ts","sourceRoot":"","sources":["../../../src/api/default/emojis.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,UAAU,EACV,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,EACrB,WAAW,EACX,SAAS,EACT,eAAe,EACf,8BAA8B,EACjC,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,KAAK,EAAE,qBAAqB,EAAE,4BAA4B,EAAE,wBAAwB,EAAE,MAAM,aAAa,CAAA;AAChH,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AAErE;;;;;;;;;;;;;;GAcG;AACH,MAAM,WAAW,MAAM;IACnB;;;;;;;;;;OAUG;IACH,GAAG,CAAC,MAAM,EAAE,mBAAmB,GAAG,UAAU,GAAG,SAAS,CAAA;IACxD;;;;OAIG;IACH,QAAQ,CACJ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,SAAS,UAAU,EAAE,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAClG;;;OAGG;IACH,aAAa,CACT,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,kBAAkB,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAC/F;;;;;;OAMG;IACH,WAAW,CACP,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,4BAA4B,GACvC,WAAW,CAAC,qBAAqB,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAClG;;;;;;OAMG;IACH,MAAM,CACF,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,WAAW,EAClB,OAAO,CAAC,EAAE,wBAAwB,GACnC,WAAW,CAAC,UAAU,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACvF;;;;;;;OAOG;IACH,UAAU,CACN,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,WAAW,EAAE,EAC7B,OAAO,CAAC,EAAE,wBAAwB,GACnC,WAAW,CAAC,eAAe,CAAC,UAAU,CAAC,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACxG;;;;OAIG;IACH,KAAK,CACD,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,wBAAwB,GACnC,WAAW,CAAC,UAAU,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACvF;;OAEG;IACH,IAAI,CACA,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,SAAS,EAChB,OAAO,CAAC,EAAE,wBAAwB,GACnC,WAAW,CAAC,UAAU,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IACvF;;;;;;OAMG;IACH,MAAM,CACF,MAAM,EAAE,mBAAmB,EAC3B,OAAO,CAAC,EAAE,8BAA8B,GACzC,WAAW,CAAC,IAAI,EAAE,qBAAqB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;CACpF"}

package/dist/api/default/emojis.js

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

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

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

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

@@ -0,0 +1,127 @@
+import type { ResultAsync } from "neverthrow";
+import type { OperationOptions } from "#sdk/client";
+import type { CancelledError, ConfigurationError } from "#sdk/errors";
+import type { EventOverflowError, EventReadError } from "#sdk/message-errors";
+import type { Message, MessageCore } from "#sdk/messages";
+import type { EventInvocation, EventWaitOptions, HandlerOptions, EventMap, EventName } from "#sdk/events";
+import type { FailureReport } from "#sdk/failures";
+/**
+ * Control one event subscription returned by on or subscribe.
+ * Closing this subscription leaves the client and its other subscriptions running.
+ * Use `await using` to close the subscription and wait for its cleanup when the enclosing block ends
+ *
+ * @category Events and collectors
+ */
+export interface Subscription {
+    /** Identifier of this subscription, such as messageCreate#3, used in failure reports and log records */
+    readonly id: string;
+    /**
+     * Stop new deliveries, drop queued events and stop running handlers, without waiting for the handler that called close.
+     * When queued events are dropped, one events.discarded Debug record reports how many, and
+     * diagnostics().counters.eventsDropped.closed counts them
+     *
+     * @remarks
+     * Returns immediately and signals running handlers to stop.
+     * JavaScript promises that ignore the signal cannot be forcibly stopped
+     */
+    close(): void;
+    /**
+     * Wait until this subscription has closed and the SDK has released its queue and listeners.
+     * Normal closure succeeds with no value, and overflow fails with EventOverflowError, even for a later waiter.
+     * Cancelling this wait affects only the waiter, not the subscription or other waiters.
+     * Later waits see the same subscription outcome.
+     * Do not await this subscription's own closure from inside its handler
+     *
+     * @remarks
+     * This does not wait for arbitrary application promises.
+     * Unexpected cleanup failures reject with SdkDefect
+     */
+    waitForClose(options?: OperationOptions): ResultAsync<void, EventOverflowError | CancelledError | ConfigurationError>;
+    /**
+     * Close this subscription and wait for its cleanup, as `await using` does at the end of a block.
+     * An overflow outcome is not rethrown here. Read it from waitForClose when it matters
+     */
+    [Symbol.asyncDispose](): Promise<void>;
+}
+/**
+ * Read future events one at a time with next, then end the subscription with close.
+ * Each subscription receives the event type chosen in client.subscribe and keeps no previously delivered history.
+ * The default event type is messageCreate
+ *
+ * @category Events and collectors
+ */
+export interface EventSubscription<K extends EventName = "messageCreate", M extends MessageCore = Message> extends Subscription {
+    /**
+     * Wait for the next event, returning Ok(payload), or Ok(null) after normal closure.
+     * Only one pending next call is allowed.
+     * Another call returns EventReadBusyError.
+     * Aborting options.signal cancels this read without closing the subscription.
+     * Overflow discards the queue and remains an Err.
+     * Unexpected SDK failures reject with SdkDefect
+     */
+    next(options?: OperationOptions): ResultAsync<EventMap<M>[K] | null, EventReadError | CancelledError | ConfigurationError>;
+}
+/**
+ * Configure how client.on schedules handlers and reports their failures.
+ * The type parameter T is the event payload that a partition function receives
+ *
+ * @category Events and collectors
+ */
+export interface EventHandlerOptions<T = unknown> extends HandlerOptions<T> {
+    /**
+     * Receive this subscription's failures instead of the client-level onError: A handler that threw or rejected,
+     * with the original error and the IDs of the message being handled, or overflow that stopped the subscription.
+     * A failure only queues its report, so the hook never holds a handler slot.
+     * Reports are delivered one at a time in order, with up to 64 waiting while the hook is busy. Later ones are logged
+     * instead, with fields.reportOutcome "queueFull", and counted in diagnostics().counters.reportsDropped.
+     * A hook that throws or rejects is logged with the original failure and never retried.
+     * Reports already queued when the subscription closes are still delivered.
+     * Client shutdown does not wait for a pending hook promise. The report it was handling and any queued ones are logged
+     * at Error instead, with fields.reportOutcome "interrupted" for the report being handled and "subscriptionClosed" for
+     * queued or later reports
+     */
+    readonly onError?: (report: FailureReport) => unknown;
+}
+/**
+ * Configure a single client.waitFor call with a filter, limits and optional AbortSignal.
+ * The signal cancels this event wait, not the client
+ *
+ * @category Events and collectors
+ */
+export interface DefaultEventWaitOptions<K extends EventName, M extends MessageCore = Message> extends EventWaitOptions<K, M>, OperationOptions {
+}
+/**
+ * Event middleware for the default API, run around each client.on handler invocation that starts after registration.
+ * It receives the invocation, a next function that runs the rest of the chain and the handler, and the invocation's cancellation signal.
+ * The promise returned by next resolves when the rest of the chain has finished, whether or not it failed, and never rejects.
+ * Failures after next are reported by the SDK where they occur, so middleware can time or trace a handler but cannot hide its failure.
+ * A middleware fails when it throws, rejects, or returns or resolves an Err result, and that failure is reported like a handler failure
+ *
+ * @category Events and collectors
+ */
+export type EventMiddleware<M extends MessageCore = Message> = (invocation: EventInvocation<M>, next: () => Promise<void>, signal: AbortSignal) => unknown;
+/**
+ * Remove event middleware registered with client.use.
+ * Use `using` to remove it when the enclosing block ends
+ *
+ * @category Events and collectors
+ */
+export interface MiddlewareRegistration {
+    /** Stop applying the middleware to invocations that start later. Invocations already running keep their chain. Repeated calls do nothing */
+    close(): void;
+    /** Remove the middleware, as `using` does at the end of a block */
+    [Symbol.dispose](): void;
+}
+/**
+ * Stop receiving connection-state updates from client.observeState.
+ * Use `using` to close the observer when the enclosing block ends
+ *
+ * @category Client and lifecycle
+ */
+export interface StateObserver {
+    /** Stop delivering states and drop a pending one. Listener code already running is not cancelled. Repeated calls do nothing */
+    close(): void;
+    /** Close this observer, as `using` does at the end of a block */
+    [Symbol.dispose](): void;
+}
+//# sourceMappingURL=events.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"events.d.ts","sourceRoot":"","sources":["../../../src/api/default/events.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AACrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,cAAc,EAAE,MAAM,qBAAqB,CAAA;AAC7E,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AACzD,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,cAAc,EAAE,QAAQ,EAAE,SAAS,EAAE,MAAM,aAAa,CAAA;AACzG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,eAAe,CAAA;AAElD;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IACzB,wGAAwG;IACxG,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAA;IACnB;;;;;;;;OAQG;IACH,KAAK,IAAI,IAAI,CAAA;IACb;;;;;;;;;;OAUG;IACH,YAAY,CACR,OAAO,CAAC,EAAE,gBAAgB,GAC3B,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;IAC9E;;;OAGG;IACH,CAAC,MAAM,CAAC,YAAY,CAAC,IAAI,OAAO,CAAC,IAAI,CAAC,CAAA;CACzC;AAED;;;;;;GAMG;AACH,MAAM,WAAW,iBAAiB,CAC9B,CAAC,SAAS,SAAS,GAAG,eAAe,EACrC,CAAC,SAAS,WAAW,GAAG,OAAO,CACjC,SAAQ,YAAY;IAClB;;;;;;;OAOG;IACH,IAAI,CACA,OAAO,CAAC,EAAE,gBAAgB,GAC3B,WAAW,CAAC,QAAQ,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,GAAG,IAAI,EAAE,cAAc,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;CAC9F;AAED;;;;;GAKG;AACH,MAAM,WAAW,mBAAmB,CAAC,CAAC,GAAG,OAAO,CAAE,SAAQ,cAAc,CAAC,CAAC,CAAC;IACvE;;;;;;;;;;;OAWG;IACH,QAAQ,CAAC,OAAO,CAAC,EAAE,CAAC,MAAM,EAAE,aAAa,KAAK,OAAO,CAAA;CACxD;AAED;;;;;GAKG;AACH,MAAM,WAAW,uBAAuB,CAAC,CAAC,SAAS,SAAS,EAAE,CAAC,SAAS,WAAW,GAAG,OAAO,CACzF,SAAQ,gBAAgB,CAAC,CAAC,EAAE,CAAC,CAAC,EAAE,gBAAgB;CAAG;AAEvD;;;;;;;;GAQG;AACH,MAAM,MAAM,eAAe,CAAC,CAAC,SAAS,WAAW,GAAG,OAAO,IAAI,CAC3D,UAAU,EAAE,eAAe,CAAC,CAAC,CAAC,EAC9B,IAAI,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,EACzB,MAAM,EAAE,WAAW,KAClB,OAAO,CAAA;AAEZ;;;;;GAKG;AACH,MAAM,WAAW,sBAAsB;IACnC,4IAA4I;IAC5I,KAAK,IAAI,IAAI,CAAA;IACb,mEAAmE;IACnE,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAA;CAC3B;AAED;;;;;GAKG;AACH,MAAM,WAAW,aAAa;IAC1B,+HAA+H;IAC/H,KAAK,IAAI,IAAI,CAAA;IACb,iEAAiE;IACjE,CAAC,MAAM,CAAC,OAAO,CAAC,IAAI,IAAI,CAAA;CAC3B"}

package/dist/api/default/events.js

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

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

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

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

@@ -0,0 +1,62 @@
+import type { ResultAsync } from "neverthrow";
+import type { OperationOptions } from "#sdk/client";
+import type { CancelledError, ConfigurationError } from "#sdk/errors";
+import type { GatewaySendFailure } from "#sdk/gateway";
+/**
+ * Send gateway commands that have no SDK method, on this client's ready shards.
+ * This is an advanced escape hatch: The SDK validates the frame locally but does not know the command's meaning,
+ * and Fluxer closes the connection, ending the client, for commands it rejects.
+ * Observe replies to these commands through the raw event, subscribing before sending
+ *
+ * @category Client and lifecycle
+ */
+export interface GatewayCommands {
+    /**
+     * Send one command frame { op, d } on a Connected local shard.
+     * The data is copied through JSON encoding when the operation starts, so later changes to it have no effect, and the
+     * encoded frame must be at most 4,096 UTF-8 bytes, Fluxer's message limit. Undefined data is invalid. Pass null instead.
+     * Data JSON cannot encode, such as a cycle or a BigInt, fails with reason input.
+     * Heartbeat, Identify, Resume and server-only opcodes fail with reason reserved.
+     * Commands share the shard's outbound pacing with presence and request commands: At most 500 paced commands per
+     * rolling 60 seconds per session, retained across Resume and reset for a fresh Identify, sent in call order.
+     * Heartbeats, Identify and Resume are never delayed. At most 500 gateway.send commands may wait per shard, and
+     * further submissions fail with reason busy until transmission or cancellation releases queue capacity.
+     * Completion means the frame was handed to the connection, not that Fluxer received or accepted it.
+     * A sent Request Guild Members command, opcode 8, counts toward the 12 member requests that members.iterateChunks
+     * allows this client in any 11 seconds, or the children of one supervisor together, but this method never refuses one
+     * for that limit.
+     * Fluxer answers an opcode it does not define, missing data or invalid command fields with close code 4001 or 4002.
+     * The SDK treats both as permanent, so the client ends. Data must match Fluxer's command schema exactly.
+     * Observe any reply through the raw event, which receives every dispatch the session accepts.
+     * A shard that loses its connection before sending fails a waiting command with reason notReady, and the SDK never
+     * replays it after reconnecting. Each sent command is logged at Debug with code gateway.commandSent
+     *
+     * @remarks
+     * Cancellation through options.signal withdraws a command that is still waiting for the pacing budget and returns
+     * CancelledError. Withdrawal immediately releases its local queue capacity.
+     * A command already handed to the connection cannot be withdrawn.
+     * A malformed signal returns ConfigurationError before anything is queued. A throw from the data's own getters or
+     * toJSON rejects with SdkDefect code application.defect and the thrown value as its cause.
+     * Other unexpected failures reject with SdkDefect
+     *
+     * @example
+     * ```ts
+     * import type { Client, RawDispatch } from "@neontechspace/fluxerly"
+     * // Commands with an SDK method, such as community counts through client.guilds.fetchCounts, use that method instead
+     * export function sendCustomCommand(
+     *     client: Client,
+     *     command: { op: number; data: unknown; replyType: string },
+     *     onReply: (reply: RawDispatch) => void,
+     * ) {
+     *     // Subscribe before sending so the raw reply cannot be missed
+     *     const replies = client.on("raw", (dispatch) => {
+     *         if (dispatch.t === command.replyType) onReply(dispatch)
+     *     })
+     *     // Close the returned subscription once the reply has arrived
+     *     return client.gateway.send(0, command.op, command.data).map(() => replies)
+     * }
+     * ```
+     */
+    send(shardId: number, op: number, d: unknown, options?: OperationOptions): ResultAsync<void, GatewaySendFailure | CancelledError | ConfigurationError>;
+}
+//# sourceMappingURL=gateway.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"gateway.d.ts","sourceRoot":"","sources":["../../../src/api/default/gateway.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAC7C,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAA;AACnD,OAAO,KAAK,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,aAAa,CAAA;AACrE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA;AAEtD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC5B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA6CG;IACH,IAAI,CACA,OAAO,EAAE,MAAM,EACf,EAAE,EAAE,MAAM,EACV,CAAC,EAAE,OAAO,EACV,OAAO,CAAC,EAAE,gBAAgB,GAC3B,WAAW,CAAC,IAAI,EAAE,kBAAkB,GAAG,cAAc,GAAG,kBAAkB,CAAC,CAAA;CACjF"}

package/dist/api/default/gateway.js

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

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

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

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

@@ -0,0 +1,87 @@
+import type { DefaultPrefixCommandGuard } from "#sdk/default-commands";
+import type { PermissionName } from "#sdk/helpers";
+import type { Message, MessageCore } from "#sdk/messages";
+/**
+ * Built-in command guards for the most common access rules. Pass one or a list as a command's `guard`.
+ * Each denial carries a short reason that `onReject: "reply"` sends to the user.
+ * Invalid guard settings throw ConfigurationError when the guard is created
+ *
+ * @example
+ * ```ts
+ * 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"),
+ *                 },
+ *             },
+ *         },
+ *     })
+ * }
+ * ```
+ *
+ * @category Commands
+ */
+export interface DefaultGuards {
+    /**
+     * Allow the command only for a message that carries its community's guildId, and deny every other message without a
+     * request. Fluxer's gateway supplies the guildId with every community message, so a message without one is denied even
+     * when its channel belongs to a community
+     */
+    guildOnly<M extends MessageCore = Message>(): DefaultPrefixCommandGuard<M>;
+    /**
+     * Allow the command only in a confirmed one-to-one or group conversation, and deny every other message.
+     * A message with a guildId is denied without a request. For a message without one, the guard checks the
+     * direct-message cache, then the channel cache, and otherwise reads the channel once with directMessages.fetch,
+     * which also fills an enabled direct-message cache. Enable `cache.directMessages` to avoid a read for each
+     * invocation in the same conversation.
+     * A private conversation allows the command. A cached community channel, or a read that Fluxer answers with anything
+     * other than a private conversation, denies it. Any other read failure, such as a network failure, timeout or
+     * rejection, leaves the channel unconfirmed and fails the command, which is reported with the command name
+     */
+    dmOnly<M extends MessageCore = Message>(): DefaultPrefixCommandGuard<M>;
+    /**
+     * Allow the command only for the owner of the bot's application, as Fluxer reports it.
+     * The first invocation reads the owner's user ID with application.fetch, and the guard keeps it for the rest of the
+     * client's lifetime, so later invocations decide without a request and an ownership transfer applies to a new client.
+     * Invocations that start before the first read completes each read it.
+     * A failed read, such as a network failure, timeout or rejection, keeps nothing and fails the command, which is
+     * reported with the command name, and the next invocation reads again
+     */
+    ownerOnly<M extends MessageCore = Message>(): DefaultPrefixCommandGuard<M>;
+    /**
+     * Allow the command only for the given decimal user IDs, such as the bot owner's.
+     * An undefined argument, such as an unset environment variable, throws ConfigurationError rather than falling back
+     * to the application owner
+     */
+    ownerOnly<M extends MessageCore = Message>(ownerIds: string | readonly string[]): DefaultPrefixCommandGuard<M>;
+    /**
+     * Allow the command only when the invoking member has every named permission in the message's channel, and deny it in
+     * direct messages. The guard reads the community, member, roles and channel from enabled caches first and fetches only
+     * what is missing, at most once each per invocation, then applies permissions.calculate.
+     * A cached channel without its overwrite list is read again instead of being treated as having no overwrites.
+     * A channel read that Fluxer answers without an overwrite list has no channel overwrites, so the member's role
+     * permissions decide.
+     * In a thread, the guard also reads the thread's parent channel the same way, cache first, and decides as Fluxer
+     * does: From the parent channel's permissions, with SendMessages granted exactly when SendMessagesInThreads is.
+     * It does not check whether the member can see a private thread or whether the thread is archived or locked.
+     * A channel of a type this SDK version does not know can take its permissions from elsewhere, so a read of one
+     * without an overwrite list denies the command rather than guessing.
+     * A failed read fails the command, which is reported with the command name.
+     * The decision does not guarantee that Fluxer allows a later action
+     */
+    requirePermissions<M extends MessageCore = Message>(names: readonly PermissionName[]): DefaultPrefixCommandGuard<M>;
+}
+/**
+ * Built-in command guards, namely guildOnly, dmOnly, ownerOnly and requirePermissions
+ *
+ * @category Commands
+ */
+export declare const guards: DefaultGuards;
+//# sourceMappingURL=guards.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../../src/api/default/guards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAA+B,yBAAyB,EAAE,MAAM,uBAAuB,CAAA;AACnG,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,cAAc,CAAA;AAClD,OAAO,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,MAAM,eAAe,CAAA;AAgBzD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,MAAM,WAAW,aAAa;IAC1B;;;;OAIG;IACH,SAAS,CAAC,CAAC,SAAS,WAAW,GAAG,OAAO,KAAK,yBAAyB,CAAC,CAAC,CAAC,CAAA;IAC1E;;;;;;;;;OASG;IACH,MAAM,CAAC,CAAC,SAAS,WAAW,GAAG,OAAO,KAAK,yBAAyB,CAAC,CAAC,CAAC,CAAA;IACvE;;;;;;;OAOG;IACH,SAAS,CAAC,CAAC,SAAS,WAAW,GAAG,OAAO,KAAK,yBAAyB,CAAC,CAAC,CAAC,CAAA;IAC1E;;;;OAIG;IACH,SAAS,CAAC,CAAC,SAAS,WAAW,GAAG,OAAO,EAAE,QAAQ,EAAE,MAAM,GAAG,SAAS,MAAM,EAAE,GAAG,yBAAyB,CAAC,CAAC,CAAC,CAAA;IAC9G;;;;;;;;;;;;;;OAcG;IACH,kBAAkB,CAAC,CAAC,SAAS,WAAW,GAAG,OAAO,EAAE,KAAK,EAAE,SAAS,cAAc,EAAE,GAAG,yBAAyB,CAAC,CAAC,CAAC,CAAA;CACtH;AAED;;;;GAIG;AACH,eAAO,MAAM,MAAM,EAAE,aA4CnB,CAAA"}