@neontechspace/fluxerly 1000.0.0-nightly.12

package/dist/api/effect/service.js

@@ -0,0 +1,79 @@
+import * as Config from "effect/Config";
+import * as Context from "effect/Context";
+import * as Effect from "effect/Effect";
+import * as Layer from "effect/Layer";
+import * as Redacted from "effect/Redacted";
+import { createClient } from "./client.js";
+/** Read every Config-valued top-level setting in declaration order, keeping other values unchanged */
+function resolveOptions(options) {
+    return Effect.gen(function* () {
+        if (typeof options !== "object" || options === null || Array.isArray(options))
+            // Misuse reaches createClient unchanged, which dies with its ConfigurationError
+            return options;
+        const resolved = {};
+        for (const [key, value] of Object.entries(options))
+            resolved[key] = Config.isConfig(value) ? yield* value : value;
+        // The Redacted wrapper is removed only here, as the token is handed to the client, which masks it in every record
+        if (Redacted.isRedacted(resolved.token))
+            resolved.token = Redacted.value(resolved.token);
+        return resolved;
+    });
+}
+/**
+ * Effect service holding one native client, for applications that assemble their program from Layers.
+ * Build it with FluxerClient.layer(options) or FluxerClient.layerConfig(options), and read it with
+ * `yield* FluxerClient` or FluxerClient.use.
+ * The layer creates the client in the layer's Scope and calls shutdown when that Scope closes, awaiting SDK cleanup.
+ * Building the layer does not connect the gateway or make a request. Register handlers first, then call client.connect()
+ * or client.run(), so no event arrives before its handler exists. HTTP operations work without connecting.
+ * Each build of the layer creates its own client. Provide one layer value to share its client, since Effect reuses a
+ * layer value within one provide.
+ * The service holds the full Message shape. For a messageFields selection, call createClient directly instead
+ * @example
+ * ```ts
+ * import { Config, Effect } from "effect"
+ * import { FluxerClient } from "@neontechspace/fluxerly/effect"
+ *
+ * const program = Effect.gen(function* () {
+ *     const client = yield* FluxerClient
+ *     yield* client.on("messageCreate", (message) =>
+ *         message.content === "!ping"
+ *             ? client.messages.reply(message, { content: "Pong!" }).pipe(Effect.asVoid)
+ *             : Effect.void,
+ *     )
+ *     yield* client.run()
+ * })
+ *
+ * export const main = program.pipe(
+ *     Effect.scoped,
+ *     Effect.provide(FluxerClient.layerConfig({ token: Config.Redacted("FLUXER_BOT_TOKEN") })),
+ * )
+ * ```
+ *
+ * @category Client and lifecycle
+ */
+export class FluxerClient extends Context.Service()("@neontechspace/fluxerly/FluxerClient") {
+    /**
+     * Build the FluxerClient service from createClient settings.
+     * Invalid settings, including a missing or blank token, are misuse and the layer dies with ConfigurationError.
+     * Services required by the settings, such as those of an onError hook, become the layer's requirements, and native
+     * logging uses the Effect logger in effect where the layer is built.
+     * The client is created without connecting and is shut down when the layer's Scope closes
+     */
+    static layer(options) {
+        return Layer.effect(FluxerClient)(createClient(options));
+    }
+    /**
+     * Build the FluxerClient service from settings that may be read from Effect Config, such as
+     * `{ token: Config.Redacted("FLUXER_BOT_TOKEN") }`.
+     * Config values are read from the current ConfigProvider, by default the process environment, when the layer is built.
+     * A missing or unparsable Config value fails the layer with ConfigError before any client exists.
+     * A token that is present but blank, or another invalid setting, is misuse and the layer dies with ConfigurationError,
+     * as in FluxerClient.layer. The token stays Redacted until the client receives it and is never logged.
+     * The client is created without connecting and is shut down when the layer's Scope closes
+     */
+    static layerConfig(options) {
+        return Layer.effect(FluxerClient)(resolveOptions(options).pipe(Effect.flatMap((resolved) => createClient(resolved))));
+    }
+}
+//# sourceMappingURL=service.js.map

package/dist/api/effect/service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service.js","sourceRoot":"","sources":["../../../src/api/effect/service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,OAAO,MAAM,gBAAgB,CAAA;AACzC,OAAO,KAAK,MAAM,MAAM,eAAe,CAAA;AACvC,OAAO,KAAK,KAAK,MAAM,cAAc,CAAA;AACrC,OAAO,KAAK,QAAQ,MAAM,iBAAiB,CAAA;AAC3C,OAAO,EAAE,YAAY,EAAmC,MAAM,aAAa,CAAA;AAoB3E,sGAAsG;AACtG,SAAS,cAAc,CACnB,OAAwC;IAExC,OAAO,MAAM,CAAC,GAAG,CAAC,QAAQ,CAAC;QACvB,IAAI,OAAO,OAAO,KAAK,QAAQ,IAAI,OAAO,KAAK,IAAI,IAAI,KAAK,CAAC,OAAO,CAAC,OAAO,CAAC;YACzE,gFAAgF;YAChF,OAAO,OAAyC,CAAA;QACpD,MAAM,QAAQ,GAA4B,EAAE,CAAA;QAC5C,KAAK,MAAM,CAAC,GAAG,EAAE,KAAK,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC;YAC9C,QAAQ,CAAC,GAAG,CAAC,GAAG,MAAM,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC,KAAK,CAAC,CAAC,KAAK,CAAC,CAAC,CAAC,KAAK,CAAA;QACjE,kHAAkH;QAClH,IAAI,QAAQ,CAAC,UAAU,CAAC,QAAQ,CAAC,KAAK,CAAC;YAAE,QAAQ,CAAC,KAAK,GAAG,QAAQ,CAAC,KAAK,CAAC,QAAQ,CAAC,KAAK,CAAC,CAAA;QACxF,OAAO,QAA0C,CAAA;IACrD,CAAC,CAAC,CAAA;AACN,CAAC;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH,MAAM,OAAO,YAAa,SAAQ,OAAO,CAAC,OAAO,EAAwB,CAAC,sCAAsC,CAAC;IAC7G;;;;;;OAMG;IACH,MAAM,CAAC,KAAK,CAAuB,OAA4B;QAC3D,OAAO,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAAC,YAAY,CAAO,OAAO,CAAC,CAAC,CAAA;IAClE,CAAC;IAED;;;;;;;;OAQG;IACH,MAAM,CAAC,WAAW,CACd,OAAwC;QAExC,OAAO,KAAK,CAAC,MAAM,CAAC,YAAY,CAAC,CAC7B,cAAc,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,YAAY,CAAO,QAAQ,CAAC,CAAC,CAAC,CAC3F,CAAA;IACL,CAAC;CACJ"}

package/dist/api/effect/stickers.d.ts

@@ -0,0 +1,81 @@
+import type { GuildSticker, ExpressionReference, ExpressionMetadata, ExpressionSourceGuild, StickerCreate, StickerEdit, ExpressionBatch, ExpressionDeleteOptions } from "#sdk/expressions";
+import type * as Effect from "effect/Effect";
+import type { GuildOperationFailure, GuildOperationOptions, ModerationOptions } from "#sdk/guilds";
+/** Read, upload, edit, clone or delete custom stickers.
+ * Methods return Effects and share guild HTTP concurrency limits, deadlines and GuildOperationError failures.
+ * Reads retry eligible transient failures at most twice. Writes retry only confirmed 429 rejections.
+ * Input, permission, 404 and malformed responses do not retry. Unknown outcomes may leave writes applied.
+ * Effects start when executed, use the caller's services and await cleanup on interruption. Defects remain in Cause.
+ * Closing clients fail with ClientClosedError. Snapshots are frozen and HTTP success is not gateway acknowledgement
+ *
+ * @category Emoji and stickers
+ */
+export interface Stickers {
+    /**
+     * Replace a sticker's name, description and tags without changing its image or fetching it first.
+     * A fetched sticker can be spread into input if its identity matches the target.
+     * Unknown fields fail locally.
+     * An empty or null description clears it, and [] clears tags.
+     * The namespace's write, failure and cancellation rules apply
+     */
+    edit(target: ExpressionReference, input: StickerEdit, options?: ModerationOptions): Effect.Effect<GuildSticker, GuildOperationFailure>;
+    /**
+     * Look up cached sticker 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
+     */
+    get(target: ExpressionReference): Effect.Effect<GuildSticker | undefined>;
+    /**
+     * Fetch a community's sticker 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?: GuildOperationOptions): Effect.Effect<readonly GuildSticker[], GuildOperationFailure>;
+    /**
+     * Fetch minimal sticker metadata by decimal ID, without requiring source-community membership.
+     * This read does not populate the cache
+     */
+    fetchMetadata(id: string, options?: GuildOperationOptions): Effect.Effect<ExpressionMetadata, GuildOperationFailure>;
+    /**
+     * Fetch the public presentation of the community that owns a custom sticker 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 sticker 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?: GuildOperationOptions): Effect.Effect<ExpressionSourceGuild, GuildOperationFailure>;
+    /**
+     * Upload one community sticker 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: StickerCreate, options?: ModerationOptions): Effect.Effect<GuildSticker, GuildOperationFailure>;
+    /**
+     * Upload 1–50 community stickers 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 sticker 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 StickerCreate[], options?: ModerationOptions): Effect.Effect<ExpressionBatch<GuildSticker>, GuildOperationFailure>;
+    /**
+     * Copy a sticker 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?: ModerationOptions): Effect.Effect<GuildSticker, GuildOperationFailure>;
+    /**
+     * Remove a sticker, 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?: ExpressionDeleteOptions): Effect.Effect<void, GuildOperationFailure>;
+}
+//# sourceMappingURL=stickers.d.ts.map

package/dist/api/effect/stickers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stickers.d.ts","sourceRoot":"","sources":["../../../src/api/effect/stickers.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACR,YAAY,EACZ,mBAAmB,EACnB,kBAAkB,EAClB,qBAAqB,EACrB,aAAa,EACb,WAAW,EACX,eAAe,EACf,uBAAuB,EAC1B,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAC5C,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,iBAAiB,EAAE,MAAM,aAAa,CAAA;AAElG;;;;;;;;GAQG;AACH,MAAM,WAAW,QAAQ;IACrB;;;;;;OAMG;IACH,IAAI,CACA,MAAM,EAAE,mBAAmB,EAC3B,KAAK,EAAE,WAAW,EAClB,OAAO,CAAC,EAAE,iBAAiB,GAC5B,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,qBAAqB,CAAC,CAAA;IACrD;;;;;;OAMG;IACH,GAAG,CAAC,MAAM,EAAE,mBAAmB,GAAG,MAAM,CAAC,MAAM,CAAC,YAAY,GAAG,SAAS,CAAC,CAAA;IACzE;;;;OAIG;IACH,QAAQ,CACJ,OAAO,EAAE,MAAM,EACf,OAAO,CAAC,EAAE,qBAAqB,GAChC,MAAM,CAAC,MAAM,CAAC,SAAS,YAAY,EAAE,EAAE,qBAAqB,CAAC,CAAA;IAChE;;;OAGG;IACH,aAAa,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB,GAAG,MAAM,CAAC,MAAM,CAAC,kBAAkB,EAAE,qBAAqB,CAAC,CAAA;IACpH;;;;;;OAMG;IACH,WAAW,CACP,EAAE,EAAE,MAAM,EACV,OAAO,CAAC,EAAE,qBAAqB,GAChC,MAAM,CAAC,MAAM,CAAC,qBAAqB,EAAE,qBAAqB,CAAC,CAAA;IAC9D;;;;;;OAMG;IACH,MAAM,CACF,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,aAAa,EACpB,OAAO,CAAC,EAAE,iBAAiB,GAC5B,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,qBAAqB,CAAC,CAAA;IACrD;;;;;;;OAOG;IACH,UAAU,CACN,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,aAAa,EAAE,EAC/B,OAAO,CAAC,EAAE,iBAAiB,GAC5B,MAAM,CAAC,MAAM,CAAC,eAAe,CAAC,YAAY,CAAC,EAAE,qBAAqB,CAAC,CAAA;IACtE;;;;OAIG;IACH,KAAK,CACD,OAAO,EAAE,MAAM,EACf,QAAQ,EAAE,MAAM,EAChB,OAAO,CAAC,EAAE,iBAAiB,GAC5B,MAAM,CAAC,MAAM,CAAC,YAAY,EAAE,qBAAqB,CAAC,CAAA;IACrD;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,EAAE,mBAAmB,EAAE,OAAO,CAAC,EAAE,uBAAuB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,qBAAqB,CAAC,CAAA;CACrH"}

package/dist/api/effect/stickers.js

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

package/dist/api/effect/stickers.js.map

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

package/dist/api/effect/supervisor.d.ts

@@ -0,0 +1,56 @@
+/**
+ * Run bot workers in separate Node processes on this machine.
+ * The create method validates the process plan when executed but starts no children.
+ * The start method launches those children once and waits for their assignment and configuration acknowledgements, not gateway READY.
+ * The waitForReady method waits for a later all-child READY state without starting or stopping the supervisor.
+ * The waitForClose method waits until every owned child exits. Cancelling that wait does not stop the children.
+ * The status method returns a frozen snapshot of each child's latest reported gateway state for its current process generation.
+ * The snapshot is local, not a simultaneous health check across processes
+ *
+ * Each child module must execute supervisor.child.run, which owns a nested client and an inter-process communication (IPC) cleanup scope.
+ * The helper preserves the caller's Effect services and Cause. It asks the parent for a permit immediately before each fresh gateway Identify.
+ * Identify authenticates a new gateway session. Resuming an existing session needs no permit.
+ * Only one parent permit can be outstanding. The child confirms its synchronous Identify send or cancels before sending.
+ * The parent spaces fresh sends by at least one second, unless identify.coordinator paces them.
+ * A stalled child must stop and exit before another permit is issued, followed by a full spacing interval
+ *
+ * The supervisor can size the plan at start with totalShards "auto", share the Identify budget through identify.coordinator and
+ * include each child's client diagnostics in status. Children keep resumable sessions through clientOptions.sharding.sessions.
+ * The children share Fluxer's limits per bot account through the parent. When one child is rate-limited globally, the parent
+ * holds the other children's REST requests until the same time. Member requests from all children share one count of 12 in
+ * any 11 seconds, and a members.iterateChunks request past it fails at once with reason rateLimit and retryAfterMs.
+ * A child that gets no answer from the parent within one second counts only its own member requests and logs
+ * supervisor.memberRequestsLocal once. Per-route REST rate limits stay per child, and other processes using the same
+ * token are not counted.
+ * It installs no signal handlers and does not terminate the process.
+ * After the configured graceful deadline, the parent can terminate only its own unresponsive child and still waits for its exit.
+ * A crashed child restarts by default, up to three times in a row with exponentially increasing delays.
+ * Set restart to false to turn this off.
+ * The childEnvironment, args and execArgv options configure children but never appear in status or failures.
+ * Child output follows childOutput: Lines are forwarded with a child label by default, and inherit or ignore can be chosen instead
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { supervisor } from "@neontechspace/fluxerly/effect"
+ *
+ * export const workers = Effect.gen(function* () {
+ *     const managed = yield* supervisor.create({
+ *         entry: "/srv/bot-worker.js",
+ *         totalShards: 2,
+ *         assignments: [
+ *             { id: "one", shardIds: [0] },
+ *             { id: "two", shardIds: [1] },
+ *         ],
+ *     })
+ *     yield* managed.start().pipe(
+ *         Effect.andThen(managed.waitForClose()),
+ *         Effect.ensuring(managed.shutdown()),
+ *     )
+ *     return managed.status()
+ * })
+ * ```
+ *
+ * @category Sharding and supervision
+ */
+export declare const supervisor: import("#sdk/native-supervisor").NativeSupervisorTools;
+//# sourceMappingURL=supervisor.d.ts.map

package/dist/api/effect/supervisor.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor.d.ts","sourceRoot":"","sources":["../../../src/api/effect/supervisor.ts"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,eAAO,MAAM,UAAU,EAAE,OAAO,wBAAwB,EAAE,qBAAwD,CAAA"}

package/dist/api/effect/supervisor.js

@@ -0,0 +1,58 @@
+import { makeNativeSupervisor } from "#sdk/native-supervisor";
+import { openClient } from "./client.js";
+/**
+ * Run bot workers in separate Node processes on this machine.
+ * The create method validates the process plan when executed but starts no children.
+ * The start method launches those children once and waits for their assignment and configuration acknowledgements, not gateway READY.
+ * The waitForReady method waits for a later all-child READY state without starting or stopping the supervisor.
+ * The waitForClose method waits until every owned child exits. Cancelling that wait does not stop the children.
+ * The status method returns a frozen snapshot of each child's latest reported gateway state for its current process generation.
+ * The snapshot is local, not a simultaneous health check across processes
+ *
+ * Each child module must execute supervisor.child.run, which owns a nested client and an inter-process communication (IPC) cleanup scope.
+ * The helper preserves the caller's Effect services and Cause. It asks the parent for a permit immediately before each fresh gateway Identify.
+ * Identify authenticates a new gateway session. Resuming an existing session needs no permit.
+ * Only one parent permit can be outstanding. The child confirms its synchronous Identify send or cancels before sending.
+ * The parent spaces fresh sends by at least one second, unless identify.coordinator paces them.
+ * A stalled child must stop and exit before another permit is issued, followed by a full spacing interval
+ *
+ * The supervisor can size the plan at start with totalShards "auto", share the Identify budget through identify.coordinator and
+ * include each child's client diagnostics in status. Children keep resumable sessions through clientOptions.sharding.sessions.
+ * The children share Fluxer's limits per bot account through the parent. When one child is rate-limited globally, the parent
+ * holds the other children's REST requests until the same time. Member requests from all children share one count of 12 in
+ * any 11 seconds, and a members.iterateChunks request past it fails at once with reason rateLimit and retryAfterMs.
+ * A child that gets no answer from the parent within one second counts only its own member requests and logs
+ * supervisor.memberRequestsLocal once. Per-route REST rate limits stay per child, and other processes using the same
+ * token are not counted.
+ * It installs no signal handlers and does not terminate the process.
+ * After the configured graceful deadline, the parent can terminate only its own unresponsive child and still waits for its exit.
+ * A crashed child restarts by default, up to three times in a row with exponentially increasing delays.
+ * Set restart to false to turn this off.
+ * The childEnvironment, args and execArgv options configure children but never appear in status or failures.
+ * Child output follows childOutput: Lines are forwarded with a child label by default, and inherit or ignore can be chosen instead
+ * @example
+ * ```ts
+ * import { Effect } from "effect"
+ * import { supervisor } from "@neontechspace/fluxerly/effect"
+ *
+ * export const workers = Effect.gen(function* () {
+ *     const managed = yield* supervisor.create({
+ *         entry: "/srv/bot-worker.js",
+ *         totalShards: 2,
+ *         assignments: [
+ *             { id: "one", shardIds: [0] },
+ *             { id: "two", shardIds: [1] },
+ *         ],
+ *     })
+ *     yield* managed.start().pipe(
+ *         Effect.andThen(managed.waitForClose()),
+ *         Effect.ensuring(managed.shutdown()),
+ *     )
+ *     return managed.status()
+ * })
+ * ```
+ *
+ * @category Sharding and supervision
+ */
+export const supervisor = makeNativeSupervisor(openClient);
+//# sourceMappingURL=supervisor.js.map

package/dist/api/effect/supervisor.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"supervisor.js","sourceRoot":"","sources":["../../../src/api/effect/supervisor.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,oBAAoB,EAAE,MAAM,wBAAwB,CAAA;AAC7D,OAAO,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAExC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqDG;AACH,MAAM,CAAC,MAAM,UAAU,GAA2D,oBAAoB,CAAC,UAAU,CAAC,CAAA"}

package/dist/api/effect/threads.d.ts

@@ -0,0 +1,154 @@
+import type * as Effect from "effect/Effect";
+import type * as Stream from "effect/Stream";
+import type { GuildThreadChannel, ThreadMember, ChannelOperationFailure, ChannelOperationOptions, ChannelAuditOperationOptions } from "#sdk/channels";
+import type { Message, MessageCore, MessageReference } from "#sdk/messages";
+import type { PaginationError } from "#sdk/pagination";
+import type { ArchivedThreadPage, ArchivedThreadQuery, ForumPost, ForumPostCreate, ThreadCreate, ThreadEdit, ThreadFromMessageCreate, ThreadMemberIterationQuery, ThreadMemberPageQuery, ThreadMemberQuery, ThreadSearchPage, ThreadSearchQuery } from "#sdk/threads";
+/** Create threads and forum posts, change, list and search threads, and manage thread members.
+ * HTTP methods return Effects and do not connect the gateway.
+ * Bots can use threads in every community where Fluxer enables them, without a capability setting.
+ * Read a thread with channels.fetch, delete it with channels.delete and send to it with messages.send and its ID
+ *
+ * Supply decimal IDs. Thread requests share this client's REST slots and queue limits with the other HTTP methods.
+ * Total deadline defaults to the client's rest.defaultTimeoutMs, 30,000 ms unless configured, including queue waits,
+ * retries and rate-limit waits. Reads retry transport failures and HTTP 500/502/503/504 at most twice.
+ * Writes retry only confirmed 429 responses, and no write is followed by an automatic confirmation fetch
+ *
+ * Manage Threads is an elevated permission.
+ * In a community whose mfaLevel is GuildMfaLevels.Elevated, an action that needs it fails with apiError.code twoFactorRequired, unless the bot owns the community or its application owner has two-factor authentication enabled.
+ * The create, createFromMessage, createPost and edit methods accept ChannelAuditOperationOptions, and the other methods
+ * reject auditReason. The fetchActive list enters the enabled channel cache, while archived pages, search results,
+ * forum posts and member reads do not. The edit, join, leave, addMember and removeMember methods remove their thread
+ * from the enabled channel cache
+ *
+ * Operation inputs are copied when the Effect executes. Expected failures use ChannelOperationError, whose operation
+ * names the threads method, or ClientClosedError. Interruption and defects retain Cause after owned cleanup
+ *
+ * @category Channels
+ */
+export interface Threads<M extends MessageCore = Message> {
+    /**
+     * Create a thread that is not attached to a message in a text or announcement channel, and return its frozen
+     * snapshot. The bot becomes the thread's first member, and Fluxer posts a ThreadCreated notice in the parent channel
+     * for a public or announcement thread.
+     * Fluxer requires Create Public Threads, or Create Private Threads for a private thread.
+     * Use createPost in a forum or media channel.
+     * A lost response can leave the thread created, and the SDK never resends it
+     *
+     * @example
+     * ```ts
+     * import { Effect } from "effect"
+     * import { ChannelType, ThreadAutoArchiveMinutes, type Client } from "@neontechspace/fluxerly/effect"
+     * export const threadExample = (client: Client, channelId: string) =>
+     *     client.threads
+     *         .create(channelId, {
+     *             name: "Release planning",
+     *             type: ChannelType.PrivateThread,
+     *             autoArchiveMinutes: ThreadAutoArchiveMinutes.OneDay,
+     *         })
+     *         .pipe(Effect.flatMap((thread) => client.messages.send(thread.id, "Planning starts here")))
+     * ```
+     */
+    create(channelId: string, input: ThreadCreate, options?: ChannelAuditOperationOptions): Effect.Effect<GuildThreadChannel, ChannelOperationFailure>;
+    /**
+     * Start a public thread on an existing message and return its frozen snapshot.
+     * The thread takes the message's ID, and the message gains MessageFlags.HasThread.
+     * Only a default message or a reply in a text or announcement channel can start a thread, and only one.
+     * In an announcement channel the thread is an announcement thread.
+     * Fluxer posts a ThreadCreated notice in the parent channel unless the message is among its five newest messages.
+     * Fluxer requires Create Public Threads and Read Message History.
+     * A lost response can leave the thread created, and the SDK never resends it.
+     * After an unknown outcome, channels.fetch(message.id) shows whether the thread exists
+     */
+    createFromMessage(message: MessageReference, input: ThreadFromMessageCreate, options?: ChannelAuditOperationOptions): Effect.Effect<GuildThreadChannel, ChannelOperationFailure>;
+    /**
+     * Create a post in a forum or media channel, a public thread with its first message, and return both frozen.
+     * Files in the message are sent inline as multipart form data in the same request, never through presigned uploads,
+     * under messages.send's attachment rules and the client's upload budget.
+     * Fluxer requires Send Messages in the channel plus the permissions the message content needs, and applies the
+     * channel's tag rules. When the first message fails, Fluxer removes the new post again.
+     * A lost response can leave the post created, and the SDK never resends it
+     */
+    createPost(channelId: string, input: ForumPostCreate, options?: ChannelAuditOperationOptions): Effect.Effect<ForumPost<M>, ChannelOperationFailure>;
+    /**
+     * Change only the supplied thread settings and return the frozen thread.
+     * It uses the route and rate limit of channels.edit. ThreadEdit describes which changes the thread's creator may
+     * make and which need Manage Threads
+     */
+    edit(threadId: string, input: ThreadEdit, options?: ChannelAuditOperationOptions): Effect.Effect<GuildThreadChannel, ChannelOperationFailure>;
+    /**
+     * Fetch every active thread the bot can view in a community, newest first, as one frozen list.
+     * A private thread appears when the bot joined it or can manage threads in its parent channel.
+     * Each thread the bot joined has membership set
+     */
+    fetchActive(guildId: string, options?: ChannelOperationOptions): Effect.Effect<readonly GuildThreadChannel[], ChannelOperationFailure>;
+    /**
+     * Fetch one frozen page of archived threads of a text, announcement, forum or media channel, as ArchivedThreadQuery
+     * selects. Scopes "public" and "private" list the most recently archived first, and "joinedPrivate" lists the newest
+     * threads first. Each thread the bot joined has membership set.
+     * Fluxer requires Read Message History, plus Manage Threads for scope "private"
+     */
+    fetchArchived(channelId: string, query?: ArchivedThreadQuery, options?: ChannelOperationOptions): Effect.Effect<ArchivedThreadPage, ChannelOperationFailure>;
+    /**
+     * Search the threads of a text, announcement, forum or media channel by name, tags and state, and return one frozen
+     * page. Fluxer requires Read Message History.
+     * While Fluxer builds the community's search index it answers HTTP 202 with code SEARCH_INDEX_NOT_READY, which this
+     * method returns as an indexing page without retrying. Any other HTTP 202 answer fails with reason response.
+     * While Fluxer's search service is turned off, the call fails with reason rejected and apiError.providerCode
+     * FEATURE_TEMPORARILY_DISABLED
+     */
+    search(channelId: string, query?: ThreadSearchQuery, options?: ChannelOperationOptions): Effect.Effect<ThreadSearchPage<M>, ChannelOperationFailure>;
+    /**
+     * Add the bot to a thread, succeeding with no value after HTTP 204. Joining a thread the bot already belongs to also
+     * succeeds. An archived thread cannot be joined, and a locked one needs Manage Threads
+     */
+    join(threadId: string, options?: ChannelOperationOptions): Effect.Effect<void, ChannelOperationFailure>;
+    /**
+     * Remove the bot from a thread, succeeding with no value after HTTP 204.
+     * An archived thread cannot be left, and Fluxer rejects a bot that is not a member with UNKNOWN_THREAD_MEMBER
+     */
+    leave(threadId: string, options?: ChannelOperationOptions): Effect.Effect<void, ChannelOperationFailure>;
+    /**
+     * Add a community member who can view the parent channel to a thread, succeeding with no value after HTTP 204.
+     * Adding a current member also succeeds, and otherwise Fluxer posts a RecipientAdd notice in the thread.
+     * Fluxer requires Send Messages In Threads, plus Manage Threads in a locked thread and in a private thread that is
+     * not invitable, unless the added member can manage threads. An archived thread accepts no new members
+     */
+    addMember(threadId: string, userId: string, options?: ChannelOperationOptions): Effect.Effect<void, ChannelOperationFailure>;
+    /**
+     * Remove a member from a thread, succeeding with no value after HTTP 204, and Fluxer posts a RecipientRemove notice
+     * in the thread. Removing the bot's own ID works like leave.
+     * Fluxer requires Manage Threads unless the bot created the private thread. A user who is not a member fails with
+     * UNKNOWN_THREAD_MEMBER, and an archived thread cannot change
+     */
+    removeMember(threadId: string, userId: string, options?: ChannelOperationOptions): Effect.Effect<void, ChannelOperationFailure>;
+    /**
+     * Fetch one thread member as a frozen ThreadMember. A user who is not a member fails with UNKNOWN_THREAD_MEMBER.
+     * With withMember, member holds the user's community membership while the user has one. Its community comes from
+     * the channel cache when the thread is cached there, otherwise from one extra channel read that shares the deadline
+     * and whose failure fails this call
+     */
+    fetchMember(threadId: string, userId: string, query?: ThreadMemberQuery, options?: ChannelOperationOptions): Effect.Effect<ThreadMember, ChannelOperationFailure>;
+    /**
+     * Fetch one page of thread members in ascending user ID order, as frozen ThreadMember values.
+     * With withMember, each member holds the user's community membership while the user has one, with the community
+     * resolved as fetchMember describes
+     */
+    fetchMembers(threadId: string, query?: ThreadMemberPageQuery, options?: ChannelOperationOptions): Effect.Effect<readonly ThreadMember[], ChannelOperationFailure>;
+    /**
+     * Read thread members in ascending user ID order, buffering one page and never prefetching.
+     * The maxItems option is required. The pageSize option defaults to 100 and accepts 1–100, maxPages defaults to 100,
+     * and timeoutMs applies to each page. An empty page or maxItems ends the scan.
+     * Invalid traversal input, a stalled cursor or reaching the page budget fails with PaginationError, and remote
+     * failures keep threads.fetchMembers's errors.
+     * With withMember, one consumption resolves the thread's community once, as fetchMember describes.
+     * Each consumption is independent, and client closure releases the page and fails the next pull
+     *
+     * @remarks
+     * The returned Stream reads pages only while it is consumed.
+     * Failures end the Stream in its error channel.
+     * Interruption waits for request cleanup, and ending consumption releases the buffered page
+     */
+    iterateMembers(threadId: string, query: ThreadMemberIterationQuery, options?: ChannelOperationOptions): Stream.Stream<ThreadMember, ChannelOperationFailure | PaginationError>;
+}
+//# sourceMappingURL=threads.d.ts.map

package/dist/api/effect/threads.d.ts.map

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

package/dist/api/effect/threads.js

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

package/dist/api/effect/threads.js.map

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

package/dist/api/effect/users.d.ts

@@ -0,0 +1,62 @@
+import type { User, UserProfile, UserProfileQuery, UserOperationFailure, UserOperationOptions } from "#sdk/users";
+import type * as Effect from "effect/Effect";
+/** Read public account information or a privacy-filtered profile.
+ * Methods return Effects with the client's default deadline (rest.defaultTimeoutMs, 30,000 ms unless configured) and at most two eligible transient read retries.
+ * Writes retry only confirmed rate-limit rejection, never an unknown outcome. No gateway connection is required.
+ * Cancellation and unexpected faults remain in Cause rather than becoming UserOperationError
+ *
+ * @category Users and DMs
+ */
+export interface Users {
+    /**
+     * Look up a public account 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
+     */
+    get(id: string): Effect.Effect<User | undefined>;
+    /**
+     * Look up the bot's own public account as the gateway's READY reported it, without a request.
+     * The result is undefined until this client's first READY, and also while no READY has carried a complete public account.
+     * A later READY with a complete public account, such as for a new session, replaces it, while an incomplete one keeps the previous account.
+     * Other user updates and fetchSelf results do not change it, so its username or avatar can be stale.
+     * The value remains available after the client stops.
+     * This lookup never fails. Use fetchSelf for a current remote snapshot
+     */
+    getSelf(): Effect.Effect<User | undefined>;
+    /**
+     * Fetch a public account snapshot by decimal user ID.
+     * An unknown user fails with reason notFound rather than an empty result.
+     * With the user cache enabled, a concurrent fetch of another user ID does not keep this result from being stored, unless more than 256 user IDs are being read at once
+     */
+    fetch(id: string, options?: UserOperationOptions): Effect.Effect<User, UserOperationFailure>;
+    /**
+     * Fetch a user's privacy-filtered profile, optionally for the community specified in query.guildId.
+     * The frozen result includes only documented identity and profile fields.
+     * The isLimited field reports Fluxer's privacy restriction, not missing community membership.
+     * A guildProfile of null means no contextual profile was supplied, not proof the user is outside the community.
+     * No gateway connection, hidden member fetch or account or profile cache use is performed, and each call issues a separate read.
+     * Users' shared deadlines and eligible read retries apply.
+     * Fluxer may clear expired premium state while serving this GET.
+     * Invalid input, denied access or a malformed response fails with UserOperationError for users.fetchProfile.
+     * Cancellation affects this request only and waits for cleanup
+     *
+     * @example
+     * ```ts
+     * import type { Client } from "@neontechspace/fluxerly/effect"
+     * export function profileExample(client: Client, userId: string, guildId: string) {
+     *     return client.users.fetchProfile(userId, { guildId })
+     * }
+     * ```
+     */
+    fetchProfile(id: string, query?: UserProfileQuery, options?: UserOperationOptions): Effect.Effect<UserProfile, UserOperationFailure>;
+    /**
+     * Fetch the authenticated bot's public account data remotely.
+     * Private account fields are excluded.
+     * With the user cache enabled, the bot's ID is unknown until the response arrives, so some concurrent user cache changes keep the result out of the cache.
+     * Examples are another users.fetch or users.fetchSelf call, a user update event and a lost gateway connection
+     */
+    fetchSelf(options?: UserOperationOptions): Effect.Effect<User, UserOperationFailure>;
+}
+//# sourceMappingURL=users.d.ts.map

package/dist/api/effect/users.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"users.d.ts","sourceRoot":"","sources":["../../../src/api/effect/users.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,IAAI,EAAE,WAAW,EAAE,gBAAgB,EAAE,oBAAoB,EAAE,oBAAoB,EAAE,MAAM,YAAY,CAAA;AACjH,OAAO,KAAK,KAAK,MAAM,MAAM,eAAe,CAAA;AAE5C;;;;;;GAMG;AACH,MAAM,WAAW,KAAK;IAClB;;;;;;OAMG;IACH,GAAG,CAAC,EAAE,EAAE,MAAM,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,GAAG,SAAS,CAAC,CAAA;IAChD;;;;;;;OAOG;IACH,OAAO,IAAI,MAAM,CAAC,MAAM,CAAC,IAAI,GAAG,SAAS,CAAC,CAAA;IAC1C;;;;OAIG;IACH,KAAK,CAAC,EAAE,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAA;IAC5F;;;;;;;;;;;;;;;;;;OAkBG;IACH,YAAY,CACR,EAAE,EAAE,MAAM,EACV,KAAK,CAAC,EAAE,gBAAgB,EACxB,OAAO,CAAC,EAAE,oBAAoB,GAC/B,MAAM,CAAC,MAAM,CAAC,WAAW,EAAE,oBAAoB,CAAC,CAAA;IACnD;;;;;OAKG;IACH,SAAS,CAAC,OAAO,CAAC,EAAE,oBAAoB,GAAG,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,oBAAoB,CAAC,CAAA;CACvF"}

package/dist/api/effect/users.js

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

package/dist/api/effect/users.js.map

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