@effect-app/vue 4.0.0-beta.16 → 4.0.0-beta.160

package/tsconfig.src.json

@@ -1,36 +1,36 @@
 {
-    "extends": "../../tsconfig.base.json",
-    "compilerOptions": {
-        "lib": [
-            "esnext",
-            "DOM"
-        ],
-        "tsBuildInfoFile": "./dist/.tsbuildinfo",
-        "esModuleInterop": true,
-        "rootDir": "./src",
-        // keep in here, cause madge can't detect it from extended tsconfig
-        "moduleResolution": "Node16",
-        "outDir": "./dist"
-    },
-    "include": [
-        "./src/**/*.ts"
+  "extends": "../../tsconfig.base.json",
+  "compilerOptions": {
+    "lib": [
+      "esnext",
+      "DOM"
     ],
-    "exclude": [
-        "./dist",
-        "*.test.ts",
-        "node_modules",
-        "build",
-        "lib",
-        "dist",
-        "**/*.d.ts.map",
-        ".git",
-        ".data",
-        "**/.*",
-        "**/*.tmp"
-    ],
-    "references": [
-        {
-            "path": "../effect-app"
-        }
-    ]
-}
+    "tsBuildInfoFile": "./dist/.tsbuildinfo",
+    "esModuleInterop": true,
+    "rootDir": "./src",
+    // keep in here, cause madge can't detect it from extended tsconfig
+    "moduleResolution": "Node16",
+    "outDir": "./dist"
+  },
+  "include": [
+    "./src/**/*.ts"
+  ],
+  "exclude": [
+    "./dist",
+    "*.test.ts",
+    "node_modules",
+    "build",
+    "lib",
+    "dist",
+    "**/*.d.ts.map",
+    ".git",
+    ".data",
+    "**/.*",
+    "**/*.tmp"
+  ],
+  "references": [
+    {
+      "path": "../effect-app"
+    }
+  ]
+}

package/tsconfig.test.json

@@ -28,6 +28,6 @@
   "references": [
     {
       "path": "./tsconfig.src.json"
-    },
+    }
   ]
-}
+}

package/vitest.config.ts

@@ -1,18 +1,18 @@
 /// <reference types="vitest" />
+import vue from "@vitejs/plugin-vue"
 import { defineConfig } from "vitest/config"
-import vue from '@vitejs/plugin-vue'
 import makeConfig from "../../vite.config.base"
 
 export default defineConfig({
   ...makeConfig(__dirname),
   plugins: [vue()],
   test: {
-    environment: 'jsdom',
-    include: ['src/**/*.test.{ts,tsx}', '**/test/**/*.test.{ts,tsx}', '**/__tests__/**/*.test.{ts,tsx}'],
-    exclude: ['node_modules/**', 'dist/**'],
+    environment: "jsdom",
+    include: ["src/**/*.test.{ts,tsx}", "**/test/**/*.test.{ts,tsx}", "**/__tests__/**/*.test.{ts,tsx}"],
+    exclude: ["node_modules/**", "dist/**"],
     globals: true
   },
   optimizeDeps: {
-    exclude: ['**/__tests__/**', '**/test/**', '**/*.test.*']
+    exclude: ["**/__tests__/**", "**/test/**", "**/*.test.*"]
   }
 })

package/dist/experimental/commander.d.ts

@@ -1,359 +0,0 @@
-import { type MissingDependencies } from "@effect-app/vue";
-import { Effect, type Exit, type Fiber, Layer, Option, ServiceMap } from "effect-app";
-import { type AsyncResult } from "effect/unstable/reactivity/AsyncResult";
-import { type FormatXMLElementFn, type PrimitiveType } from "intl-messageformat";
-import { type ComputedRef } from "vue";
-import { Confirm } from "./confirm.js";
-import { I18n } from "./intl.js";
-import { WithToast } from "./withToast.js";
-type IntlRecord = Record<string, PrimitiveType | FormatXMLElementFn<string, string>>;
-type FnOptions<Id extends string, I18nCustomKey extends string, State extends IntlRecord | undefined> = {
-    i18nCustomKey?: I18nCustomKey;
-    /**
-     * passed to the i18n formatMessage calls so you can use it in translation messagee
-     * including the Command `action` string.
-     * Automatically wrapped with Computed if just a thunk.
-     * provided as Command.state tag, so you can access it in the function.
-     */
-    state?: ComputedRef<State> | (() => State);
-    blockKey?: (id: Id) => string | undefined;
-    waitKey?: (id: Id) => string | undefined;
-    allowed?: (id: Id, state: ComputedRef<State>) => boolean;
-};
-type FnOptionsInternal<I18nCustomKey extends string> = {
-    i18nCustomKey?: I18nCustomKey | undefined;
-    state?: IntlRecord | undefined;
-};
-export declare const DefaultIntl: {
-    de: {
-        "handle.confirmation": string;
-        "handle.waiting": string;
-        "handle.success": string;
-        "handle.with_errors": string;
-        "handle.with_warnings": string;
-        "handle.error_response": string;
-        "handle.response_error": string;
-        "handle.request_error": string;
-        "handle.unexpected_error2": string;
-        "handle.unexpected_error": string;
-        "handle.not_found": string;
-    };
-    en: {
-        "handle.confirmation": string;
-        "handle.waiting": string;
-        "handle.success": string;
-        "handle.with_errors": string;
-        "handle.with_warnings": string;
-        "handle.error_response": string;
-        "handle.request_error": string;
-        "handle.response_error": string;
-        "handle.unexpected_error2": string;
-        "handle.unexpected_error": string;
-        "handle.not_found": string;
-    };
-};
-declare const CommandContext_base: ServiceMap.ServiceClass<CommandContext, "CommandContext", {
-    id: string;
-    i18nKey: string;
-    action: string;
-    label: string;
-    namespace: string;
-    namespaced: (key: string) => string;
-    state?: IntlRecord | undefined;
-}>;
-export declare class CommandContext extends CommandContext_base {
-}
-export type EmitWithCallback<A, Event extends string> = (event: Event, value: A, onDone: () => void) => void;
-/**
- * Use to wrap emit calls with a callback to signal completion.
- * Useful when the publisher wants to wait for the subscriber to finish processing.
- */
-export declare const wrapEmit: <A, Event extends string>(emit: EmitWithCallback<A, NoInfer<Event>>, event: Event) => (value: A) => Promise<void>;
-export declare namespace Commander {
-    type CommanderBase<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = Gen<RT, Id, I18nKey, State> & NonGen<RT, Id, I18nKey, State> & CommandContextLocal<Id, I18nKey> & {
-        state: ServiceMap.Service<`Commander.Command.${Id}.state`, State>;
-    };
-    type CommanderFn<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = CommanderBase<RT, Id, I18nKey, State>;
-    type CommanderWrap<RT, Id extends string, I18nCustomKey extends string, State extends IntlRecord | undefined, I, A, E, R> = CommandContextLocal<Id, I18nCustomKey> & GenWrap<RT, Id, I18nCustomKey, I, A, E, R, State> & NonGenWrap<RT, Id, I18nCustomKey, I, A, E, R, State> & {
-        state: ServiceMap.Service<`Commander.Command.${Id}.state`, State>;
-    };
-    interface CommandContextLocal<Id extends string, I18nKey extends string> {
-        id: Id;
-        i18nKey: I18nKey;
-        namespace: `action.${I18nKey}`;
-        namespaced: <K extends string>(k: K) => `action.${I18nKey}.${K}`;
-    }
-    interface CommandProps<A, E, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> extends CommandContextLocal<Id, I18nKey> {
-        /** reactive */
-        action: string;
-        /** reactive */
-        label: string;
-        /** reactive */
-        result: AsyncResult<A, E>;
-        /** reactive */
-        waiting: boolean;
-        /** reactive */
-        blocked: boolean;
-        /** reactive */
-        allowed: boolean;
-        /** reactive */
-        state: State;
-    }
-    interface CommandOut<Arg, A, E, R, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> extends CommandProps<A, E, Id, I18nKey, State> {
-        new (): {};
-        /** click handlers */
-        handle: ((arg: Arg) => Fiber.Fiber<Exit.Exit<A, E>, never>) & {
-            /** @deprecated don't exist */
-            effect: (arg: Arg) => Effect.Effect<A, E, R>;
-        };
-    }
-    interface CommandContextLocal2<Id extends string, I18nKey extends string, State extends IntlRecord | undefined> extends CommandContextLocal<Id, I18nKey> {
-        state: State;
-    }
-    type CommandOutHelper<Arg, Eff extends Effect.Effect<any, any, any>, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = CommandOut<Arg, Effect.Success<Eff>, Effect.Error<Eff>, Effect.Services<Eff>, Id, I18nKey, State>;
-    type Gen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
-        <Eff extends Effect.Yieldable<any, any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, AEff, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>): CommandOut<Arg, AEff, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never, Id, I18nKey, State>;
-        <Eff extends Effect.Yieldable<any, any, any, any>, AEff, A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>, a: (_: Effect.Effect<AEff, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A): CommandOutHelper<Arg, A, Id, I18nKey, State>;
-        <Eff extends Effect.Yieldable<any, any, any, any>, AEff, A, B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>, a: (_: Effect.Effect<AEff, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B): CommandOutHelper<Arg, B, Id, I18nKey, State>;
-        <Eff extends Effect.Yieldable<any, any, any, any>, AEff, A, B, C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>, a: (_: Effect.Effect<AEff, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C): CommandOutHelper<Arg, C, Id, I18nKey, State>;
-        <Eff extends Effect.Yieldable<any, any, any, any>, AEff, A, B, C, D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>, a: (_: Effect.Effect<AEff, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D): CommandOutHelper<Arg, D, Id, I18nKey, State>;
-        <Eff extends Effect.Yieldable<any, any, any, any>, AEff, A, B, C, D, E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>, a: (_: Effect.Effect<AEff, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E): CommandOutHelper<Arg, E, Id, I18nKey, State>;
-        <Eff extends Effect.Yieldable<any, any, any, any>, AEff, A, B, C, D, E, F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>, a: (_: Effect.Effect<AEff, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F): CommandOutHelper<Arg, F, Id, I18nKey, State>;
-        <Eff extends Effect.Yieldable<any, any, any, any>, AEff, A, B, C, D, E, F, G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>, a: (_: Effect.Effect<AEff, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G): CommandOutHelper<Arg, G, Id, I18nKey, State>;
-        <Eff extends Effect.Yieldable<any, any, any, any>, AEff, A, B, C, D, E, F, G, H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>, a: (_: Effect.Effect<AEff, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G, h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H): CommandOutHelper<Arg, H, Id, I18nKey, State>;
-        <Eff extends Effect.Yieldable<any, any, any, any>, AEff, A, B, C, D, E, F, G, H, I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>, a: (_: Effect.Effect<AEff, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer E, infer _R>] ? E : never, [
-            Eff
-        ] extends [never] ? never : [Eff] extends [Effect.Yieldable<any, infer _A, infer _E, infer R>] ? R : never>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G, h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H, i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I): CommandOutHelper<Arg, I, Id, I18nKey, State>;
-    };
-    type NonGen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, A, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A, a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, A, B, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A, a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, A, B, C, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A, a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, A, B, C, D, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A, a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, A, B, C, D, E, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A, a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, A, B, C, D, E, F, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A, a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, A, B, C, D, E, F, G, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A, a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G, g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, A, B, C, D, E, F, G, H, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A, a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G, g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H, h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, A, B, C, D, E, F, G, H, I, Arg = void>(body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A, a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G, g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H, h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I, i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-    };
-    type GenWrap<RT, Id extends string, I18nKey extends string, Arg, AEff, EEff, REff, State extends IntlRecord | undefined> = {
-        (): Exclude<REff, RT> extends never ? CommandOut<Arg, AEff, EEff, REff, Id, I18nKey, State> : MissingDependencies<RT, REff> & {};
-        <A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A): CommandOutHelper<Arg, A, Id, I18nKey, State>;
-        <A, B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B): CommandOutHelper<Arg, B, Id, I18nKey, State>;
-        <A, B, C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C): CommandOutHelper<Arg, C, Id, I18nKey, State>;
-        <A, B, C, D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D): CommandOutHelper<Arg, D, Id, I18nKey, State>;
-        <A, B, C, D, E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E): CommandOutHelper<Arg, E, Id, I18nKey, State>;
-        <A, B, C, D, E, F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F): CommandOutHelper<Arg, F, Id, I18nKey, State>;
-        <A, B, C, D, E, F, G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G): CommandOutHelper<Arg, G, Id, I18nKey, State>;
-        <A, B, C, D, E, F, G, H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G, h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H): CommandOutHelper<Arg, H, Id, I18nKey, State>;
-        <A, B, C, D, E, F, G, H, I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => A, b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G, h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H, i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I): CommandOutHelper<Arg, I, Id, I18nKey, State>;
-    };
-    type NonGenWrap<RT, Id extends string, I18nKey extends string, Arg, AEff, EEff, REff, State extends IntlRecord | undefined> = {
-        (): Exclude<REff, RT> extends never ? CommandOutHelper<Arg, Effect.Effect<AEff, EEff, REff>, Id, I18nKey, State> : MissingDependencies<RT, REff> & {};
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, Arg>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, B, Arg>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, B, C, Arg>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, B, C, D, Arg>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, B, C, D, E, Arg>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, B, C, D, E, F, Arg>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, B, C, D, E, F, G, Arg>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G, g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, B, C, D, E, F, G, H, Arg>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G, g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H, h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-        <Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>, B, C, D, E, F, G, H, I, Arg>(a: (_: Effect.Effect<AEff, EEff, REff>, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B, b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C, c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D, d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E, e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F, f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G, g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H, h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I, i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff): CommandOutHelper<Arg, Eff, Id, I18nKey, State>;
-    };
-}
-type ErrorRenderer<E, Args extends readonly any[]> = (e: E, action: string, ...args: Args) => string | undefined;
-export declare const CommanderStatic: {
-    accessArgs: <In, Out, Arg2, Arg = void>(cb: (a: NoInfer<Arg>, b: NoInfer<Arg2>) => (self: NoInfer<In>) => Out) => (self: In, arg: Arg, arg2: Arg2) => Out;
-    /** Version of @see confirmOrInterrupt that automatically includes the action name in the default messages */
-    confirmOrInterrupt: (message?: string | undefined) => Effect.Effect<void, never, I18n | Confirm | CommandContext>;
-    /** Version of @see confirm that automatically includes the action name in the default messages */
-    confirm: (message?: string | undefined) => Effect.Effect<boolean, never, I18n | Confirm | CommandContext>;
-    updateAction: <Args extends Array<unknown>>(update: (currentActionId: string, ...args: Args) => string) => <A, E, R>(_: Effect.Effect<A, E, R>, ...input: Args) => Effect.Effect<A, E, CommandContext | R>;
-    defaultFailureMessageHandler: <E, Args extends Array<unknown>, AME, AMR>(actionMaker: string | ((o: Option.Option<E>, ...args: Args) => string) | ((o: Option.Option<E>, ...args: Args) => Effect.Effect<string, AME, AMR>), errorRenderer?: ErrorRenderer<E, Args>) => (o: Option.Option<E>, ...args: Args) => Effect.Effect<string | {
-        level: "warn";
-        message: string;
-    }, AME, I18n | AMR>;
-    renderError: Effect.Effect<(<E, Args extends readonly any[]>(action: string, errorRenderer?: ErrorRenderer<E, Args>) => (e: E, ...args: Args) => string), never, I18n>;
-    /**
-     * Version of withDefaultToast that automatically includes the action name in the default messages and uses intl.
-     * uses the Command id as i18n namespace.  `action.{id}` is the main action name,
-     * and `action.{id}.waiting`, `action.{id}.success`, `action.{id}.failure` can be used to override the default messages for the respective states.
-     *
-     * the computed `state` provided to the Command can be used for interpolation in the i18n messages. (the state is captured at the start of each command execution and remains stable throughout)
-     *
-     * Note: if you provide `onWaiting` or `onSuccess` as `null`, no toast will be shown for that state.
-     * If you provide a string or function, it will be used instead of the i18n message.
-     * If you provide an `errorRenderer`, it will be used to render errors in the failure message.
-     */
-    withDefaultToast: <A, E, R, Args extends Array<unknown>>(options?: {
-        /**
-         * if true, previous toasts with this key will be replaced
-         */
-        stableToastId?: undefined | true | string | ((id: string, ...args: Args) => true | string | undefined);
-        errorRenderer?: ErrorRenderer<E, Args>;
-        onWaiting?: null | undefined | string | ((id: string, ...args: Args) => string | null | undefined);
-        onSuccess?: null | undefined | string | ((a: A, action: string, ...args: Args) => string | null | undefined);
-    }) => (self: Effect.Effect<A, E, R>, ...args: Args) => Effect.Effect<A, E, I18n | WithToast | CommandContext | R>;
-    /** borrowing the idea from Families in Effect Atom */
-    family: <T extends object, Arg, ArgIn = Arg>(maker: (arg: Arg) => T, keyMaker?: (arg: ArgIn) => Arg) => (arg: ArgIn) => T;
-};
-export declare class CommanderImpl<RT, RTHooks> {
-    private readonly rt;
-    private readonly intl;
-    private readonly hooks;
-    constructor(rt: ServiceMap.ServiceMap<RT>, intl: I18n, hooks: Layer.Layer<RTHooks, never, RT>);
-    readonly makeContext: <const Id extends string, const I18nKey extends string = Id>(id: Id, options?: FnOptionsInternal<I18nKey>) => {
-        id: string;
-        i18nKey: string;
-        action: string;
-        label: string;
-        namespace: string;
-        namespaced: (key: string) => string;
-        state?: IntlRecord | undefined;
-    };
-    readonly makeCommand: <const Id extends string, const State extends IntlRecord | undefined, const I18nKey extends string = Id>(id_: Id | {
-        id: Id;
-    }, options?: FnOptions<Id, I18nKey, State>, errorDef?: Error) => (<Arg, A, E, R extends RT | RTHooks | CommandContext | `Commander.Command.${Id}.state`>(handler: (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>) => {
-        id: import("vue").UnwrapRef<Id>;
-        i18nKey: string;
-        namespace: string;
-        namespaced: (key: string) => string;
-        result: AsyncResult<A, E>;
-        waiting: boolean;
-        blocked: boolean;
-        allowed: boolean;
-        action: string;
-        label: string;
-        state: State;
-        handle: ((arg: Arg) => Fiber.Fiber<Exit.Exit<A, E>, never>) & {
-            action: ComputedRef<string>;
-            label: ComputedRef<string>;
-        };
-    }) & {
-        id: Id;
-    };
-    /**
-     * Define a Command for handling user actions with built-in error reporting and state management.
-     *
-     * @param id The internal identifier for the action. Used as a tracing span and to lookup
-     *                   the user-facing name via internationalization (`action.${id}`).
-     * @param options Optional configuration for internationalization and state.
-     * @param options.i18nCustomKey Custom i18n key to use instead of `id` (e.g., for grouping similar actions)
-     * @param options.state Optional reactive state object (or function returning one) that is
-     *                     made available to the command effects and can be used for i18n interpolation.
-     *                     The state is captured at the start of each command execution and remains stable throughout.
-     * @returns A function that executes the command when called (e.g., directly in `@click` handlers).
-     *          Built-in error reporting handles failures automatically.
-     *
-     * **Effect Context**: Effects have access to the `CommandContext` service, which provides
-     * the user-facing action name.
-     *
-     * **Returned Properties**:
-     * - `action`: User-facing action name from intl messages (useful for button labels)
-     * - `result`: The command result state
-     * - `waiting`: Boolean indicating if the command is in progress (shorthand for `result.waiting`)
-     * - `handle`: Function to execute the command
-     * - `exec`: The raw Effect that will be executed when calling `handle` (for advanced use cases)
-     * - `i18nKey`, `namespace`, `namespaced`: Helpers for internationalization keys
-     *
-     * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
-     * the `result` inline for custom UI feedback.
-     */
-    fn: <const Id extends string, const State extends IntlRecord = IntlRecord, const I18nKey extends string = Id>(id: Id | {
-        id: Id;
-    }, options?: FnOptions<Id, I18nKey, State>) => Commander.Gen<RT | RTHooks, Id, I18nKey, State> & Commander.NonGen<RT | RTHooks, Id, I18nKey, State> & {
-        state: ServiceMap.Service<`Commander.Command.${Id}.state`, State>;
-    };
-    /** @experimental @deprecated */
-    alt2: <const Id extends string, MutArg, MutA, MutE, MutR, const I18nKey extends string = Id, State extends IntlRecord | undefined = undefined>(id: Id | {
-        id: Id;
-        mutate: (arg: MutArg) => Effect.Effect<MutA, MutE, MutR>;
-    } | (((arg: MutArg) => Effect.Effect<MutA, MutE, MutR>) & {
-        id: Id;
-    }), options?: FnOptions<Id, I18nKey, State>) => Commander.CommandContextLocal<Id, I18nKey> & (<A, E, R extends RT | RTHooks | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(handler: (ctx: Effect.fn.Traced & Effect.fn.Untraced & Commander.CommandContextLocal<Id, I18nKey> & {
-        mutate: (arg: Arg) => Effect.Effect<MutA, MutE, MutR>;
-    }) => (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>) => Commander.CommandOut<Arg, A, E, R, Id, I18nKey, State>);
-    /** @experimental */
-    alt: <const Id extends string, const I18nKey extends string = Id, State extends IntlRecord | undefined = undefined>(id: Id, customI18nKey?: I18nKey) => Commander.CommandContextLocal<Id, I18nKey> & (<A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(handler: (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>) => Commander.CommandOut<Arg, A, E, R, Id, I18nKey, State>);
-    /**
-     * Define a Command for handling user actions with built-in error reporting and state management.
-     *
-     * @param mutation The mutation function to take the identifier and initial handler from. Used as a tracing span and to lookup
-     *                   the user-facing name via internationalization (`action.${id}`).
-     * @param options Optional configuration for internationalization and state.
-     * @param options.i18nCustomKey Custom i18n key to use instead of `id` (e.g., for grouping similar actions)
-     * @param options.state Optional reactive state object (or function returning one) that is
-     *                     made available to the command effects and can be used for i18n interpolation.
-     *                     The state is captured at the start of each command execution and remains stable throughout.
-     * @returns A function that executes the command when called (e.g., directly in `@click` handlers).
-     *          Built-in error reporting handles failures automatically.
-     *
-     * **Effect Context**: Effects have access to the `CommandContext` service, which provides
-     * the user-facing action name.
-     *
-     * **Returned Properties**:
-     * - `action`: User-facing action name from intl messages (useful for button labels)
-     * - `result`: The command result state
-     * - `waiting`: Boolean indicating if the command is in progress (shorthand for `result.waiting`)
-     * - `handle`: Function to execute the command
-     * - `exec`: The raw Effect that will be executed when calling `handle` (for advanced use cases)
-     * - `i18nKey`, `namespace`, `namespaced`: Helpers for internationalization keys
-     *
-     * **User Feedback**: Use the `withDefaultToast` helper for status notifications, or render
-     * the `result` inline for custom UI feedback.
-     */
-    wrap: <const Id extends string, Arg, A, E, R, const State extends IntlRecord = IntlRecord, I18nKey extends string = Id>(mutation: {
-        mutate: (arg: Arg) => Effect.Effect<A, E, R>;
-        id: Id;
-    } | (((arg: Arg) => Effect.Effect<A, E, R>) & {
-        id: Id;
-    }), options?: FnOptions<Id, I18nKey, State>) => Commander.CommanderWrap<RT | RTHooks, Id, I18nKey, State, Arg, A, E, R>;
-}
-declare const Commander_base: ServiceMap.ServiceClass<Commander, "Commander", <RT, RTHooks>(rt: ServiceMap.ServiceMap<RT>, rtHooks: Layer.Layer<RTHooks, never, RT>) => CommanderImpl<RT, RTHooks>> & {
-    readonly make: Effect.Effect<(<RT, RTHooks>(rt: ServiceMap.ServiceMap<RT>, rtHooks: Layer.Layer<RTHooks, never, RT>) => CommanderImpl<RT, RTHooks>), never, I18n>;
-};
-export declare class Commander extends Commander_base {
-    static readonly DefaultWithoutDependencies: Layer.Layer<Commander, never, I18n>;
-    static readonly Default: Layer.Layer<Commander, never, I18n>;
-}
-export {};
-//# sourceMappingURL=commander.d.ts.map