dfx 0.56.0 → 0.56.1

package/DiscordGateway/Shard.d.ts

@@ -9,7 +9,7 @@ import * as Layer from "@effect/io/Layer";
 import { Tag } from "@effect/data/Context";
 import * as Hub from "@effect/io/Hub";
 import * as Queue from "@effect/io/Queue";
-export declare const make: Effect.Effect<RateLimiter | Log | DiscordConfig | DiscordWS, never, {
+export declare const make: Effect.Effect<DiscordConfig | Log | RateLimiter | DiscordWS, never, {
     readonly connect: (shard: [id: number, count: number], hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>, sendQueue: Queue.Dequeue<Discord.GatewayPayload<Discord.SendEvent>>) => Effect.Effect<never, never, {
         readonly id: [id: number, count: number];
         readonly send: (p: Message) => Effect.Effect<never, never, boolean>;
@@ -19,7 +19,7 @@ export declare const make: Effect.Effect<RateLimiter | Log | DiscordConfig | Dis
 export interface Shard extends Effect.Effect.Success<typeof make> {
 }
 export declare const Shard: Tag<Shard, Shard>;
-export declare const LiveShard: Layer.Layer<import("dfx/RateLimit").RateLimitStore | Log | DiscordConfig | import("dfx/DiscordGateway/DiscordWS").DiscordWSCodec, never, Shard>;
+export declare const LiveShard: Layer.Layer<DiscordConfig | Log | import("dfx/RateLimit").RateLimitStore | import("dfx/DiscordGateway/DiscordWS").DiscordWSCodec, never, Shard>;
 export interface RunningShard extends Effect.Effect.Success<ReturnType<Shard["connect"]>> {
 }
 //# sourceMappingURL=Shard.d.ts.map

package/DiscordGateway/Sharder.d.ts

@@ -12,13 +12,13 @@ import type { WebSocketCloseError, WebSocketError } from "dfx/DiscordGateway/WS"
 import { DiscordREST } from "dfx/DiscordREST";
 import { RateLimiter } from "dfx/RateLimit";
 import type * as Discord from "dfx/types";
-declare const make: Effect.Effect<RateLimiter | DiscordREST | DiscordConfig | ShardStore | Shard, never, {
+declare const make: Effect.Effect<DiscordConfig | RateLimiter | DiscordREST | Shard | ShardStore, never, {
     readonly shards: Effect.Effect<never, never, HashSet.HashSet<RunningShard>>;
     readonly run: (hub: Hub.Hub<Discord.GatewayPayload<Discord.ReceiveEvent>>, sendQueue: Queue.Dequeue<Discord.GatewayPayload<Discord.SendEvent>>) => Effect.Effect<never, WebSocketError | WebSocketCloseError, never>;
 }>;
 export interface Sharder extends Effect.Effect.Success<typeof make> {
 }
 export declare const Sharder: Tag<Sharder, Sharder>;
-export declare const LiveSharder: Layer.Layer<import("dfx/RateLimit").RateLimitStore | import("../Log").Log | DiscordREST | DiscordConfig | ShardStore | import("./DiscordWS").DiscordWSCodec, never, Sharder>;
+export declare const LiveSharder: Layer.Layer<DiscordConfig | import("../Log").Log | import("dfx/RateLimit").RateLimitStore | DiscordREST | import("./DiscordWS").DiscordWSCodec | ShardStore, never, Sharder>;
 export {};
 //# sourceMappingURL=Sharder.d.ts.map

package/DiscordGateway.d.ts

@@ -17,5 +17,5 @@ export interface DiscordGateway {
 }
 export declare const DiscordGateway: Tag<DiscordGateway, DiscordGateway>;
 export declare const make: Effect.Effect<Sharder, never, DiscordGateway>;
-export declare const LiveDiscordGateway: Layer.Layer<import("./RateLimit").RateLimitStore | import("./Log").Log | import("./DiscordREST").DiscordREST | import("./DiscordConfig").DiscordConfig | import("./DiscordGateway/ShardStore").ShardStore | import("./DiscordGateway/DiscordWS").DiscordWSCodec, never, DiscordGateway>;
+export declare const LiveDiscordGateway: Layer.Layer<import("./DiscordConfig").DiscordConfig | import("./Log").Log | import("./RateLimit").RateLimitStore | import("./DiscordREST").DiscordREST | import("./DiscordGateway/DiscordWS").DiscordWSCodec | import("./DiscordGateway/ShardStore").ShardStore, never, DiscordGateway>;
 //# sourceMappingURL=DiscordGateway.d.ts.map

package/DiscordREST.d.ts

@@ -18,5 +18,5 @@ export interface DiscordREST extends Discord.Endpoints<Partial<Http.MakeOptions>
     readonly executor: <A = unknown>(request: Http.Request) => Effect.Effect<never, DiscordRESTError, ResponseWithData<A>>;
 }
 export declare const DiscordREST: Tag<DiscordREST, DiscordREST>;
-export declare const LiveDiscordREST: Layer.Layer<RateLimitStore | Log | DiscordConfig | Http.HttpRequestExecutor, never, DiscordREST>;
+export declare const LiveDiscordREST: Layer.Layer<DiscordConfig | Http.HttpRequestExecutor | Log | RateLimitStore, never, DiscordREST>;
 //# sourceMappingURL=DiscordREST.d.ts.map

package/Interactions/context.d.ts

@@ -30,7 +30,7 @@ export declare class SubCommandNotFound {
     readonly _tag = "SubCommandNotFound";
     constructor(data: Discord.ApplicationCommandDatum);
 }
-export declare const handleSubCommands: <NER extends Record<string, Effect.Effect<any, any, Discord.InteractionResponse>>>(commands: NER) => Effect.Effect<Discord.Interaction | Discord.ApplicationCommandDatum | Exclude<[NER[keyof NER]] extends [{
+export declare const handleSubCommands: <NER extends Record<string, Effect.Effect<any, any, Discord.InteractionResponse>>>(commands: NER) => Effect.Effect<Discord.ApplicationCommandDatum | Discord.Interaction | Exclude<[NER[keyof NER]] extends [{
     [Effect.EffectTypeId]: {
         _R: (_: never) => infer R;
     };

package/Interactions/definitions.d.ts

@@ -9,14 +9,14 @@ export declare class GlobalApplicationCommand<R, E> {
     readonly _tag = "GlobalApplicationCommand";
     constructor(command: Discord.CreateGlobalApplicationCommandParams, handle: CommandHandler<R, E>);
 }
-export declare const global: <R, E, const A extends DeepReadonlyObject<Discord.CreateGlobalApplicationCommandParams>>(command: A, handle: CommandHandler<R, E, A>) => GlobalApplicationCommand<Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>, E>;
+export declare const global: <R, E, const A extends DeepReadonlyObject<Discord.CreateGlobalApplicationCommandParams>>(command: A, handle: CommandHandler<R, E, A>) => GlobalApplicationCommand<Exclude<R, Discord.ApplicationCommandDatum | Discord.Interaction>, E>;
 export declare class GuildApplicationCommand<R, E> {
     readonly command: Discord.CreateGuildApplicationCommandParams;
     readonly handle: CommandHandler<R, E>;
     readonly _tag = "GuildApplicationCommand";
     constructor(command: Discord.CreateGuildApplicationCommandParams, handle: CommandHandler<R, E>);
 }
-export declare const guild: <R, E, const A extends DeepReadonlyObject<Discord.CreateGuildApplicationCommandParams>>(command: A, handle: CommandHandler<R, E, A>) => GuildApplicationCommand<Exclude<R, Discord.Interaction | Discord.ApplicationCommandDatum>, E>;
+export declare const guild: <R, E, const A extends DeepReadonlyObject<Discord.CreateGuildApplicationCommandParams>>(command: A, handle: CommandHandler<R, E, A>) => GuildApplicationCommand<Exclude<R, Discord.ApplicationCommandDatum | Discord.Interaction>, E>;
 export declare class MessageComponent<R, E> {
     readonly predicate: (customId: string) => Effect.Effect<R, E, boolean>;
     readonly handle: Effect.Effect<R, E, Discord.InteractionResponse>;
@@ -37,7 +37,7 @@ export declare class Autocomplete<R, E> {
     readonly _tag = "Autocomplete";
     constructor(predicate: (data: Discord.ApplicationCommandDatum, focusedOption: Discord.ApplicationCommandInteractionDataOption) => Effect.Effect<R, E, boolean>, handle: Effect.Effect<R, E, Discord.InteractionResponse>);
 }
-export declare const autocomplete: <R1, R2, E1, E2>(pred: (data: Discord.ApplicationCommandDatum, focusedOption: Discord.ApplicationCommandInteractionDataOption) => Effect.Effect<R1, E1, boolean>, handle: Effect.Effect<R2, E2, Discord.InteractionResponse>) => Autocomplete<Exclude<R1, Discord.Interaction | Discord.ApplicationCommandDatum | FocusedOptionContext> | Exclude<R2, Discord.Interaction | Discord.ApplicationCommandDatum | FocusedOptionContext>, E1 | E2>;
+export declare const autocomplete: <R1, R2, E1, E2>(pred: (data: Discord.ApplicationCommandDatum, focusedOption: Discord.ApplicationCommandInteractionDataOption) => Effect.Effect<R1, E1, boolean>, handle: Effect.Effect<R2, E2, Discord.InteractionResponse>) => Autocomplete<Exclude<R1, Discord.ApplicationCommandDatum | Discord.Interaction | FocusedOptionContext> | Exclude<R2, Discord.ApplicationCommandDatum | Discord.Interaction | FocusedOptionContext>, E1 | E2>;
 type DeepReadonly<T> = T extends (infer R)[] ? ReadonlyArray<DeepReadonly<R>> : T extends Function ? T : T extends object ? DeepReadonlyObject<T> : T;
 type DeepReadonlyObject<T> = {
     readonly [P in keyof T]: DeepReadonly<T[P]>;

package/Interactions/gateway.d.ts

@@ -16,7 +16,7 @@ export interface RunOpts {
 /**
  * @tsplus pipeable dfx/InteractionBuilder runGateway
  */
-export declare const run: <R, R2, E, TE, E2>(postHandler: (effect: Effect.Effect<Discord.Interaction | DiscordREST | R, DefinitionNotFound | DiscordRESTError | TE, void>) => Effect.Effect<R2, E2, void>, { sync }?: RunOpts) => (ix: InteractionBuilder<R, E, TE>) => Effect.Effect<DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>, DiscordRESTError | Http.ResponseDecodeError | E2, never>;
+export declare const run: <R, R2, E, TE, E2>(postHandler: (effect: Effect.Effect<DiscordREST | Discord.Interaction | R, DiscordRESTError | DefinitionNotFound | TE, void>) => Effect.Effect<R2, E2, void>, { sync }?: RunOpts) => (ix: InteractionBuilder<R, E, TE>) => Effect.Effect<DiscordREST | DiscordGateway | Exclude<R2, Discord.Interaction>, DiscordRESTError | Http.ResponseDecodeError | E2, never>;
 export interface InteractionsRegistry {
     readonly register: <E>(ix: InteractionBuilder<never, E, never>) => Effect.Effect<never, never, void>;
     readonly run: <R, E>(onError: (_: Cause<DiscordRESTError | DefinitionNotFound>) => Effect.Effect<R, E, void>, opts?: RunOpts) => Effect.Effect<DiscordREST | DiscordGateway | Exclude<R, Discord.Interaction>, DiscordRESTError | Http.ResponseDecodeError | E, never>;

package/Interactions/webhook.d.ts

@@ -59,7 +59,7 @@ export interface HandleWebhookOpts<E> {
 /**
  * @tsplus getter dfx/InteractionBuilder webhookHandler
  */
-export declare const makeHandler: <R, E, TE>(ix: InteractionBuilder<R, E, TE>) => ({ headers, body, success, error, }: HandleWebhookOpts<BadWebhookSignature | WebhookParseError | E | DefinitionNotFound>) => Effect.Effect<WebhookConfig, never, void>;
+export declare const makeHandler: <R, E, TE>(ix: InteractionBuilder<R, E, TE>) => ({ headers, body, success, error, }: HandleWebhookOpts<DefinitionNotFound | BadWebhookSignature | WebhookParseError | E>) => Effect.Effect<WebhookConfig, never, void>;
 /**
  * @tsplus getter dfx/InteractionBuilder simpleWebhookHandler
  */

package/gateway.d.ts

@@ -17,7 +17,7 @@ export { DiscordGateway, LiveDiscordGateway } from "dfx/DiscordGateway";
 export { InteractionsRegistry, InteractionsRegistryLive, run as runIx, } from "dfx/Interactions/gateway";
 export { CachePrelude, DiscordWS, SendEvent, Shard, ShardStore, WS };
 export declare const MemoryRateLimit: Layer.Layer<Log.Log, never, RateLimiter>;
-export declare const MemoryBot: Layer.Layer<Log.Log | DiscordConfig.DiscordConfig | HttpRequestExecutor, never, RateLimiter | DiscordREST | InteractionsRegistry | DiscordGateway>;
+export declare const MemoryBot: Layer.Layer<DiscordConfig.DiscordConfig | HttpRequestExecutor | Log.Log, never, RateLimiter | DiscordREST | DiscordGateway | InteractionsRegistry>;
 export declare const gatewayLayerWithoutHttp: (config: Config.Config.Wrap<DiscordConfig.MakeOpts>) => Layer.Layer<HttpRequestExecutor, ConfigError.ConfigError, RateLimiter | Log.Log | InteractionsRegistry | DiscordREST | DiscordGateway | DiscordConfig.DiscordConfig>;
 export declare const gatewayLayer: (config: Config.Config.Wrap<DiscordConfig.MakeOpts>) => Layer.Layer<never, ConfigError.ConfigError, RateLimiter | Log.Log | InteractionsRegistry | DiscordREST | DiscordGateway | DiscordConfig.DiscordConfig>;
 //# sourceMappingURL=gateway.d.ts.map

package/mjs/version.mjs

@@ -1,2 +1,2 @@
-export const LIB_VERSION = "0.56.0";
+export const LIB_VERSION = "0.56.1";
 //# sourceMappingURL=version.mjs.map

package/package.json

@@ -1,15 +1,15 @@
 {
   "name": "dfx",
-  "version": "0.56.0",
+  "version": "0.56.1",
   "license": "MIT",
   "repository": {
     "type": "git",
     "url": "https://github.com/tim-smart/dfx.git"
   },
   "dependencies": {
-    "@effect-http/client": "^0.34.0",
+    "@effect-http/client": "^0.35.0",
     "@effect/data": "^0.16.0",
-    "@effect/io": "~0.35.0",
+    "@effect/io": "~0.35.1",
     "@effect/stream": "~0.29.0",
     "bufferutil": "^4.0.7",
     "discord-verify": "^1.2.0",
@@ -17,7 +17,7 @@
     "utf-8-validate": "^6.0.3",
     "ws": "^8.13.0"
   },
-  "gitHead": "bb05de086da052a87c7bb540b3f7b02f45ae6a80",
+  "gitHead": "281b59e3f8b1936f65a01609bdee74d14c8cfc54",
   "main": "./index.js",
   "publishConfig": {
     "access": "public"

package/src/version.ts

@@ -1 +1 @@
-export const LIB_VERSION = "0.56.0";
+export const LIB_VERSION = "0.56.1";

package/version.d.ts

@@ -1,2 +1,2 @@
-export declare const LIB_VERSION = "0.56.0";
+export declare const LIB_VERSION = "0.56.1";
 //# sourceMappingURL=version.d.ts.map

package/version.js

@@ -4,6 +4,6 @@ Object.defineProperty(exports, "__esModule", {
   value: true
 });
 exports.LIB_VERSION = void 0;
-const LIB_VERSION = "0.56.0";
+const LIB_VERSION = "0.56.1";
 exports.LIB_VERSION = LIB_VERSION;
 //# sourceMappingURL=version.js.map

package/webhooks.d.ts

@@ -9,7 +9,7 @@ import * as Log from "dfx/Log";
 import type { RateLimiter } from "dfx/RateLimit";
 export { BadWebhookSignature, WebhookConfig, WebhookParseError, makeConfigLayer, makeHandler, makeSimpleHandler, } from "dfx/Interactions/webhook";
 export declare const MemoryRateLimit: Layer.Layer<Log.Log, never, RateLimiter>;
-export declare const MemoryREST: Layer.Layer<Log.Log | DiscordConfig.DiscordConfig | HttpRequestExecutor, never, DiscordREST>;
+export declare const MemoryREST: Layer.Layer<DiscordConfig.DiscordConfig | HttpRequestExecutor | Log.Log, never, DiscordREST>;
 export declare const webhookLayerWithoutHttp: (options: Config.Config.Wrap<DiscordConfig.MakeOpts & MakeConfigOpts>) => Layer.Layer<HttpRequestExecutor, ConfigError.ConfigError, RateLimiter | DiscordREST | WebhookConfig>;
 export declare const webhookLayerConfig: (config: Config.Config.Wrap<DiscordConfig.MakeOpts & MakeConfigOpts>) => Layer.Layer<never, ConfigError.ConfigError, RateLimiter | DiscordREST | WebhookConfig>;
 export declare const webhookLayer: (options: DiscordConfig.MakeOpts & MakeConfigOpts) => Layer.Layer<never, never, RateLimiter | DiscordREST | WebhookConfig>;