@effect-app/vue 2.85.0 → 2.87.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
Files changed (10) hide show
  1. package/CHANGELOG.md +12 -0
  2. package/dist/experimental/commander.d.ts +77 -74
  3. package/dist/experimental/commander.d.ts.map +1 -1
  4. package/dist/experimental/commander.js +7 -7
  5. package/dist/makeClient.d.ts +11 -13
  6. package/dist/makeClient.d.ts.map +1 -1
  7. package/package.json +1 -1
  8. package/src/experimental/commander.ts +349 -316
  9. package/src/makeClient.ts +4 -10
  10. package/test/Mutation.test.ts +24 -15
package/src/experimental/commander.ts CHANGED
@@ -93,9 +93,9 @@ export const wrapEmit = <A, Event extends string>(
93
93
 
94
94
  export declare namespace Commander {
95
95
  export type CommanderBase<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> =
96
- & Commander.Gen<RT, Id, I18nKey, State>
97
- & Commander.NonGen<RT, Id, I18nKey, State>
98
- & Commander.CommandContextLocal<Id, I18nKey>
96
+ & Gen<RT, Id, I18nKey, State>
97
+ & NonGen<RT, Id, I18nKey, State>
98
+ & CommandContextLocal<Id, I18nKey>
99
99
  & {
100
100
  state: Context.Tag<`Commander.Command.${Id}.state`, State>
101
101
  }
@@ -108,7 +108,7 @@ export declare namespace Commander {
108
108
  Id extends string,
109
109
  I18nCustomKey extends string,
110
110
  State extends IntlRecord | undefined,
111
- I extends any[],
111
+ I,
112
112
  A,
113
113
  E,
114
114
  R
@@ -147,7 +147,7 @@ export declare namespace Commander {
147
147
  }
148
148
 
149
149
  export interface CommandOut<
150
- Args extends Array<unknown>,
150
+ Arg,
151
151
  A,
152
152
  E,
153
153
  R,
@@ -158,35 +158,41 @@ export declare namespace Commander {
158
158
  new(): {}
159
159
 
160
160
  /** click handlers */
161
- handle: ((...args: Args) => RuntimeFiber<Exit.Exit<A, E>, never>) & {
161
+ handle: ((arg: Arg) => RuntimeFiber<Exit.Exit<A, E>, never>) & {
162
162
  /** @deprecated don't exist */
163
- effect: (...args: Args) => Effect.Effect<A, E, R>
163
+ effect: (arg: Arg) => Effect.Effect<A, E, R>
164
164
  }
165
165
 
166
166
  // // TODO: if we keep them, it would probably be nicer as an option api, deciding the return value like in Atom?
167
167
  // /** @experimental */
168
- // compose: (...args: Args) => Effect.Effect<Exit.Exit<A, E>, R>
168
+ // compose: (arg: Arg) => Effect.Effect<Exit.Exit<A, E>, R>
169
169
  // /** @experimental */
170
- // compose2: (...args: Args) => Effect.Effect<A, E, R>
170
+ // compose2: (arg: Arg) => Effect.Effect<A, E, R>
171
171
  // /**
172
172
  // * @experimental
173
173
  // * captures the current span and returns an Effect that when run will execute the command
174
174
  // */
175
- // handleEffect: (...args: Args) => Effect.Effect<RuntimeFiber<Exit.Exit<A, E>, never>>
175
+ // handleEffect: (arg: Arg) => Effect.Effect<RuntimeFiber<Exit.Exit<A, E>, never>>
176
176
  // /**
177
177
  // * @experimental
178
178
  // */
179
- // exec: (...args: Args) => Effect.Effect<Exit.Exit<A, E>, never, Exclude<R, CommandContext>>
179
+ // exec: (arg: Arg) => Effect.Effect<Exit.Exit<A, E>, never, Exclude<R, CommandContext>>
180
+ }
181
+
182
+ export interface CommandContextLocal2<Id extends string, I18nKey extends string, State extends IntlRecord | undefined>
183
+ extends CommandContextLocal<Id, I18nKey>
184
+ {
185
+ state: State
180
186
  }
181
187
 
182
188
  type CommandOutHelper<
183
- Args extends Array<unknown>,
189
+ Arg,
184
190
  Eff extends Effect.Effect<any, any, any>,
185
191
  Id extends string,
186
192
  I18nKey extends string,
187
193
  State extends IntlRecord | undefined
188
194
  > = CommandOut<
189
- Args,
195
+ Arg,
190
196
  Effect.Effect.Success<Eff>,
191
197
  Effect.Effect.Error<Eff>,
192
198
  Effect.Effect.Context<Eff>,
@@ -199,11 +205,11 @@ export declare namespace Commander {
199
205
  <
200
206
  Eff extends YieldWrap<Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>,
201
207
  AEff,
202
- Args extends Array<unknown>
208
+ Arg = void
203
209
  >(
204
- body: (...args: Args) => Generator<Eff, AEff, never>
210
+ body: (arg: Arg) => Generator<Eff, AEff, never>
205
211
  ): CommandOut<
206
- Args,
212
+ Arg,
207
213
  AEff,
208
214
  [Eff] extends [never] ? never
209
215
  : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer E, infer _R>>] ? E
@@ -218,10 +224,10 @@ export declare namespace Commander {
218
224
  <
219
225
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
220
226
  AEff,
221
- Args extends Array<unknown>,
222
- A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
227
+ A extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
228
+ Arg = void
223
229
  >(
224
- body: (...args: Args) => Generator<Eff, AEff, never>,
230
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
225
231
  a: (
226
232
  _: Effect.Effect<
227
233
  AEff,
@@ -232,17 +238,18 @@ export declare namespace Commander {
232
238
  : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
233
239
  : never
234
240
  >,
235
- ...args: NoInfer<Args>
241
+ arg: NoInfer<Arg>,
242
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
236
243
  ) => A
237
- ): CommandOutHelper<Args, A, Id, I18nKey, State>
244
+ ): CommandOutHelper<Arg, A, Id, I18nKey, State>
238
245
  <
239
246
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
240
247
  AEff,
241
- Args extends Array<unknown>,
242
248
  A,
243
- B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
249
+ B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
250
+ Arg = void
244
251
  >(
245
- body: (...args: Args) => Generator<Eff, AEff, never>,
252
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
246
253
  a: (
247
254
  _: Effect.Effect<
248
255
  AEff,
@@ -253,19 +260,20 @@ export declare namespace Commander {
253
260
  : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
254
261
  : never
255
262
  >,
256
- ...args: NoInfer<Args>
263
+ arg: NoInfer<Arg>,
264
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
257
265
  ) => A,
258
- b: (_: A, ...args: NoInfer<Args>) => B
259
- ): CommandOutHelper<Args, B, Id, I18nKey, State>
266
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B
267
+ ): CommandOutHelper<Arg, B, Id, I18nKey, State>
260
268
  <
261
269
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
262
270
  AEff,
263
- Args extends Array<unknown>,
264
271
  A,
265
272
  B,
266
- C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
273
+ C extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
274
+ Arg = void
267
275
  >(
268
- body: (...args: Args) => Generator<Eff, AEff, never>,
276
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
269
277
  a: (
270
278
  _: Effect.Effect<
271
279
  AEff,
@@ -276,21 +284,22 @@ export declare namespace Commander {
276
284
  : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
277
285
  : never
278
286
  >,
279
- ...args: NoInfer<Args>
287
+ arg: NoInfer<Arg>,
288
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
280
289
  ) => A,
281
- b: (_: A, ...args: NoInfer<Args>) => B,
282
- c: (_: B, ...args: NoInfer<Args>) => C
283
- ): CommandOutHelper<Args, C, Id, I18nKey, State>
290
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
291
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C
292
+ ): CommandOutHelper<Arg, C, Id, I18nKey, State>
284
293
  <
285
294
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
286
295
  AEff,
287
- Args extends Array<unknown>,
288
296
  A,
289
297
  B,
290
298
  C,
291
- D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
299
+ D extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
300
+ Arg = void
292
301
  >(
293
- body: (...args: Args) => Generator<Eff, AEff, never>,
302
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
294
303
  a: (
295
304
  _: Effect.Effect<
296
305
  AEff,
@@ -301,23 +310,24 @@ export declare namespace Commander {
301
310
  : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
302
311
  : never
303
312
  >,
304
- ...args: NoInfer<Args>
313
+ arg: NoInfer<Arg>,
314
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
305
315
  ) => A,
306
- b: (_: A, ...args: NoInfer<Args>) => B,
307
- c: (_: B, ...args: NoInfer<Args>) => C,
308
- d: (_: C, ...args: NoInfer<Args>) => D
309
- ): CommandOutHelper<Args, D, Id, I18nKey, State>
316
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
317
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
318
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D
319
+ ): CommandOutHelper<Arg, D, Id, I18nKey, State>
310
320
  <
311
321
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
312
322
  AEff,
313
- Args extends Array<unknown>,
314
323
  A,
315
324
  B,
316
325
  C,
317
326
  D,
318
- E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
327
+ E extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
328
+ Arg = void
319
329
  >(
320
- body: (...args: Args) => Generator<Eff, AEff, never>,
330
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
321
331
  a: (
322
332
  _: Effect.Effect<
323
333
  AEff,
@@ -328,25 +338,26 @@ export declare namespace Commander {
328
338
  : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
329
339
  : never
330
340
  >,
331
- ...args: NoInfer<Args>
341
+ arg: NoInfer<Arg>,
342
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
332
343
  ) => A,
333
- b: (_: A, ...args: NoInfer<Args>) => B,
334
- c: (_: B, ...args: NoInfer<Args>) => C,
335
- d: (_: C, ...args: NoInfer<Args>) => D,
336
- e: (_: D, ...args: NoInfer<Args>) => E
337
- ): CommandOutHelper<Args, E, Id, I18nKey, State>
344
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
345
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
346
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
347
+ e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E
348
+ ): CommandOutHelper<Arg, E, Id, I18nKey, State>
338
349
  <
339
350
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
340
351
  AEff,
341
- Args extends Array<unknown>,
342
352
  A,
343
353
  B,
344
354
  C,
345
355
  D,
346
356
  E,
347
- F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
357
+ F extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
358
+ Arg = void
348
359
  >(
349
- body: (...args: Args) => Generator<Eff, AEff, never>,
360
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
350
361
  a: (
351
362
  _: Effect.Effect<
352
363
  AEff,
@@ -357,27 +368,28 @@ export declare namespace Commander {
357
368
  : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
358
369
  : never
359
370
  >,
360
- ...args: NoInfer<Args>
371
+ arg: NoInfer<Arg>,
372
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
361
373
  ) => A,
362
- b: (_: A, ...args: NoInfer<Args>) => B,
363
- c: (_: B, ...args: NoInfer<Args>) => C,
364
- d: (_: C, ...args: NoInfer<Args>) => D,
365
- e: (_: D, ...args: NoInfer<Args>) => E,
366
- f: (_: E, ...args: NoInfer<Args>) => F
367
- ): CommandOutHelper<Args, F, Id, I18nKey, State>
374
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
375
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
376
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
377
+ e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
378
+ f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F
379
+ ): CommandOutHelper<Arg, F, Id, I18nKey, State>
368
380
  <
369
381
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
370
382
  AEff,
371
- Args extends Array<unknown>,
372
383
  A,
373
384
  B,
374
385
  C,
375
386
  D,
376
387
  E,
377
388
  F,
378
- G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
389
+ G extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
390
+ Arg = void
379
391
  >(
380
- body: (...args: Args) => Generator<Eff, AEff, never>,
392
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
381
393
  a: (
382
394
  _: Effect.Effect<
383
395
  AEff,
@@ -388,19 +400,19 @@ export declare namespace Commander {
388
400
  : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
389
401
  : never
390
402
  >,
391
- ...args: NoInfer<Args>
403
+ arg: NoInfer<Arg>,
404
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
392
405
  ) => A,
393
- b: (_: A, ...args: NoInfer<Args>) => B,
394
- c: (_: B, ...args: NoInfer<Args>) => C,
395
- d: (_: C, ...args: NoInfer<Args>) => D,
396
- e: (_: D, ...args: NoInfer<Args>) => E,
397
- f: (_: E, ...args: NoInfer<Args>) => F,
398
- g: (_: F, ...args: NoInfer<Args>) => G
399
- ): CommandOutHelper<Args, G, Id, I18nKey, State>
406
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
407
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
408
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
409
+ e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
410
+ f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
411
+ g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G
412
+ ): CommandOutHelper<Arg, G, Id, I18nKey, State>
400
413
  <
401
414
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
402
415
  AEff,
403
- Args extends Array<unknown>,
404
416
  A,
405
417
  B,
406
418
  C,
@@ -408,9 +420,10 @@ export declare namespace Commander {
408
420
  E,
409
421
  F,
410
422
  G,
411
- H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
423
+ H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
424
+ Arg = void
412
425
  >(
413
- body: (...args: Args) => Generator<Eff, AEff, never>,
426
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
414
427
  a: (
415
428
  _: Effect.Effect<
416
429
  AEff,
@@ -421,20 +434,20 @@ export declare namespace Commander {
421
434
  : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
422
435
  : never
423
436
  >,
424
- ...args: NoInfer<Args>
437
+ arg: NoInfer<Arg>,
438
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
425
439
  ) => A,
426
- b: (_: A, ...args: NoInfer<Args>) => B,
427
- c: (_: B, ...args: NoInfer<Args>) => C,
428
- d: (_: C, ...args: NoInfer<Args>) => D,
429
- e: (_: D, ...args: NoInfer<Args>) => E,
430
- f: (_: E, ...args: NoInfer<Args>) => F,
431
- g: (_: F, ...args: NoInfer<Args>) => G,
432
- h: (_: G, ...args: NoInfer<Args>) => H
433
- ): CommandOutHelper<Args, H, Id, I18nKey, State>
440
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
441
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
442
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
443
+ e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
444
+ f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
445
+ g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
446
+ h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H
447
+ ): CommandOutHelper<Arg, H, Id, I18nKey, State>
434
448
  <
435
449
  Eff extends YieldWrap<Effect.Effect<any, any, any>>,
436
450
  AEff,
437
- Args extends Array<unknown>,
438
451
  A,
439
452
  B,
440
453
  C,
@@ -443,9 +456,10 @@ export declare namespace Commander {
443
456
  F,
444
457
  G,
445
458
  H,
446
- I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
459
+ I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
460
+ Arg = void
447
461
  >(
448
- body: (...args: Args) => Generator<Eff, AEff, never>,
462
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Generator<Eff, AEff, never>,
449
463
  a: (
450
464
  _: Effect.Effect<
451
465
  AEff,
@@ -456,70 +470,71 @@ export declare namespace Commander {
456
470
  : [Eff] extends [YieldWrap<Effect.Effect<infer _A, infer _E, infer R>>] ? R
457
471
  : never
458
472
  >,
459
- ...args: NoInfer<Args>
473
+ arg: NoInfer<Arg>,
474
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
460
475
  ) => A,
461
- b: (_: A, ...args: NoInfer<Args>) => B,
462
- c: (_: B, ...args: NoInfer<Args>) => C,
463
- d: (_: C, ...args: NoInfer<Args>) => D,
464
- e: (_: D, ...args: NoInfer<Args>) => E,
465
- f: (_: E, ...args: NoInfer<Args>) => F,
466
- g: (_: F, ...args: NoInfer<Args>) => G,
467
- h: (_: G, ...args: NoInfer<Args>) => H,
468
- i: (_: H, ...args: NoInfer<Args>) => I
469
- ): CommandOutHelper<Args, I, Id, I18nKey, State>
476
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
477
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
478
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
479
+ e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
480
+ f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
481
+ g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
482
+ h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
483
+ i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I
484
+ ): CommandOutHelper<Arg, I, Id, I18nKey, State>
470
485
  }
471
486
 
472
487
  export type NonGen<RT, Id extends string, I18nKey extends string, State extends IntlRecord | undefined> = {
473
488
  <
474
489
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
475
- Args extends Array<unknown>
490
+ Arg = void
476
491
  >(
477
- body: (...args: Args) => Eff
478
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
492
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => Eff
493
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
479
494
  <
480
495
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
481
496
  A,
482
- Args extends Array<unknown>
497
+ Arg = void
483
498
  >(
484
- body: (...args: Args) => A,
485
- a: (_: A, ...args: NoInfer<Args>) => Eff
486
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
499
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
500
+ a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
501
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
487
502
  <
488
503
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
489
504
  A,
490
505
  B,
491
- Args extends Array<unknown>
506
+ Arg = void
492
507
  >(
493
- body: (...args: Args) => A,
494
- a: (_: A, ...args: NoInfer<Args>) => B,
495
- b: (_: B, ...args: NoInfer<Args>) => Eff
496
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
508
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
509
+ a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
510
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
511
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
497
512
  <
498
513
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
499
514
  A,
500
515
  B,
501
516
  C,
502
- Args extends Array<unknown>
517
+ Arg = void
503
518
  >(
504
- body: (...args: Args) => A,
505
- a: (_: A, ...args: NoInfer<Args>) => B,
506
- b: (_: B, ...args: NoInfer<Args>) => C,
507
- c: (_: C, ...args: NoInfer<Args>) => Eff
508
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
519
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
520
+ a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
521
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
522
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
523
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
509
524
  <
510
525
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
511
526
  A,
512
527
  B,
513
528
  C,
514
529
  D,
515
- Args extends Array<unknown>
530
+ Arg = void
516
531
  >(
517
- body: (...args: Args) => A,
518
- a: (_: A, ...args: NoInfer<Args>) => B,
519
- b: (_: B, ...args: NoInfer<Args>) => C,
520
- c: (_: C, ...args: NoInfer<Args>) => D,
521
- d: (_: D, ...args: NoInfer<Args>) => Eff
522
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
532
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
533
+ a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
534
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
535
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
536
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
537
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
523
538
  <
524
539
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
525
540
  A,
@@ -527,15 +542,15 @@ export declare namespace Commander {
527
542
  C,
528
543
  D,
529
544
  E,
530
- Args extends Array<unknown>
545
+ Arg = void
531
546
  >(
532
- body: (...args: Args) => A,
533
- a: (_: A, ...args: NoInfer<Args>) => B,
534
- b: (_: B, ...args: NoInfer<Args>) => C,
535
- c: (_: C, ...args: NoInfer<Args>) => D,
536
- d: (_: D, ...args: NoInfer<Args>) => E,
537
- e: (_: E, ...args: NoInfer<Args>) => Eff
538
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
547
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
548
+ a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
549
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
550
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
551
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
552
+ e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
553
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
539
554
  <
540
555
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
541
556
  A,
@@ -544,16 +559,16 @@ export declare namespace Commander {
544
559
  D,
545
560
  E,
546
561
  F,
547
- Args extends Array<unknown>
562
+ Arg = void
548
563
  >(
549
- body: (...args: Args) => A,
550
- a: (_: A, ...args: NoInfer<Args>) => B,
551
- b: (_: B, ...args: NoInfer<Args>) => C,
552
- c: (_: C, ...args: NoInfer<Args>) => D,
553
- d: (_: D, ...args: NoInfer<Args>) => E,
554
- e: (_: E, ...args: NoInfer<Args>) => F,
555
- f: (_: F, ...args: NoInfer<Args>) => Eff
556
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
564
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
565
+ a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
566
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
567
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
568
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
569
+ e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
570
+ f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
571
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
557
572
  <
558
573
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
559
574
  A,
@@ -563,17 +578,17 @@ export declare namespace Commander {
563
578
  E,
564
579
  F,
565
580
  G,
566
- Args extends Array<unknown>
581
+ Arg = void
567
582
  >(
568
- body: (...args: Args) => A,
569
- a: (_: A, ...args: NoInfer<Args>) => B,
570
- b: (_: B, ...args: NoInfer<Args>) => C,
571
- c: (_: C, ...args: NoInfer<Args>) => D,
572
- d: (_: D, ...args: NoInfer<Args>) => E,
573
- e: (_: E, ...args: NoInfer<Args>) => F,
574
- f: (_: F, ...args: NoInfer<Args>) => G,
575
- g: (_: G, ...args: NoInfer<Args>) => Eff
576
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
583
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
584
+ a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
585
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
586
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
587
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
588
+ e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
589
+ f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
590
+ g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
591
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
577
592
  <
578
593
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
579
594
  A,
@@ -584,18 +599,18 @@ export declare namespace Commander {
584
599
  F,
585
600
  G,
586
601
  H,
587
- Args extends Array<unknown>
602
+ Arg = void
588
603
  >(
589
- body: (...args: Args) => A,
590
- a: (_: A, ...args: NoInfer<Args>) => B,
591
- b: (_: B, ...args: NoInfer<Args>) => C,
592
- c: (_: C, ...args: NoInfer<Args>) => D,
593
- d: (_: D, ...args: NoInfer<Args>) => E,
594
- e: (_: E, ...args: NoInfer<Args>) => F,
595
- f: (_: F, ...args: NoInfer<Args>) => G,
596
- g: (_: G, ...args: NoInfer<Args>) => H,
597
- h: (_: H, ...args: NoInfer<Args>) => Eff
598
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
604
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
605
+ a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
606
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
607
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
608
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
609
+ e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
610
+ f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
611
+ g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
612
+ h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
613
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
599
614
  <
600
615
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
601
616
  A,
@@ -607,33 +622,33 @@ export declare namespace Commander {
607
622
  G,
608
623
  H,
609
624
  I,
610
- Args extends Array<unknown>
625
+ Arg = void
611
626
  >(
612
- body: (...args: Args) => A,
613
- a: (_: A, ...args: NoInfer<Args>) => B,
614
- b: (_: B, ...args: NoInfer<Args>) => C,
615
- c: (_: C, ...args: NoInfer<Args>) => D,
616
- d: (_: D, ...args: NoInfer<Args>) => E,
617
- e: (_: E, ...args: NoInfer<Args>) => F,
618
- f: (_: F, ...args: NoInfer<Args>) => G,
619
- g: (_: G, ...args: NoInfer<Args>) => H,
620
- h: (_: H, ...args: NoInfer<Args>) => I,
621
- i: (_: H, ...args: NoInfer<Args>) => Eff
622
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
627
+ body: (arg: Arg, ctx: CommandContextLocal2<Id, I18nKey, State>) => A,
628
+ a: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
629
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
630
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
631
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
632
+ e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
633
+ f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
634
+ g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
635
+ h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I,
636
+ i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
637
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
623
638
  }
624
639
 
625
640
  export type GenWrap<
626
641
  RT,
627
642
  Id extends string,
628
643
  I18nKey extends string,
629
- Args extends Array<unknown>,
644
+ Arg,
630
645
  AEff,
631
646
  EEff,
632
647
  REff,
633
648
  State extends IntlRecord | undefined
634
649
  > = {
635
650
  (): Exclude<REff, RT> extends never ? CommandOut<
636
- Args,
651
+ Arg,
637
652
  AEff,
638
653
  EEff,
639
654
  REff,
@@ -651,9 +666,10 @@ export declare namespace Commander {
651
666
  EEff,
652
667
  REff
653
668
  >,
654
- ...args: NoInfer<Args>
669
+ arg: NoInfer<Arg>,
670
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
655
671
  ) => A
656
- ): CommandOutHelper<Args, A, Id, I18nKey, State>
672
+ ): CommandOutHelper<Arg, A, Id, I18nKey, State>
657
673
  <
658
674
  A,
659
675
  B extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>
@@ -664,10 +680,11 @@ export declare namespace Commander {
664
680
  EEff,
665
681
  REff
666
682
  >,
667
- ...args: NoInfer<Args>
683
+ arg: NoInfer<Arg>,
684
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
668
685
  ) => A,
669
- b: (_: A, ...args: NoInfer<Args>) => B
670
- ): CommandOutHelper<Args, B, Id, I18nKey, State>
686
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B
687
+ ): CommandOutHelper<Arg, B, Id, I18nKey, State>
671
688
  <
672
689
  A,
673
690
  B,
@@ -679,11 +696,12 @@ export declare namespace Commander {
679
696
  EEff,
680
697
  REff
681
698
  >,
682
- ...args: NoInfer<Args>
699
+ arg: NoInfer<Arg>,
700
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
683
701
  ) => A,
684
- b: (_: A, ...args: NoInfer<Args>) => B,
685
- c: (_: B, ...args: NoInfer<Args>) => C
686
- ): CommandOutHelper<Args, C, Id, I18nKey, State>
702
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
703
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C
704
+ ): CommandOutHelper<Arg, C, Id, I18nKey, State>
687
705
  <
688
706
  A,
689
707
  B,
@@ -696,12 +714,13 @@ export declare namespace Commander {
696
714
  EEff,
697
715
  REff
698
716
  >,
699
- ...args: NoInfer<Args>
717
+ arg: NoInfer<Arg>,
718
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
700
719
  ) => A,
701
- b: (_: A, ...args: NoInfer<Args>) => B,
702
- c: (_: B, ...args: NoInfer<Args>) => C,
703
- d: (_: C, ...args: NoInfer<Args>) => D
704
- ): CommandOutHelper<Args, D, Id, I18nKey, State>
720
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
721
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
722
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D
723
+ ): CommandOutHelper<Arg, D, Id, I18nKey, State>
705
724
  <
706
725
  A,
707
726
  B,
@@ -715,13 +734,14 @@ export declare namespace Commander {
715
734
  EEff,
716
735
  REff
717
736
  >,
718
- ...args: NoInfer<Args>
737
+ arg: NoInfer<Arg>,
738
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
719
739
  ) => A,
720
- b: (_: A, ...args: NoInfer<Args>) => B,
721
- c: (_: B, ...args: NoInfer<Args>) => C,
722
- d: (_: C, ...args: NoInfer<Args>) => D,
723
- e: (_: D, ...args: NoInfer<Args>) => E
724
- ): CommandOutHelper<Args, E, Id, I18nKey, State>
740
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
741
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
742
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
743
+ e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E
744
+ ): CommandOutHelper<Arg, E, Id, I18nKey, State>
725
745
  <
726
746
  A,
727
747
  B,
@@ -736,14 +756,15 @@ export declare namespace Commander {
736
756
  EEff,
737
757
  REff
738
758
  >,
739
- ...args: NoInfer<Args>
759
+ arg: NoInfer<Arg>,
760
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
740
761
  ) => A,
741
- b: (_: A, ...args: NoInfer<Args>) => B,
742
- c: (_: B, ...args: NoInfer<Args>) => C,
743
- d: (_: C, ...args: NoInfer<Args>) => D,
744
- e: (_: D, ...args: NoInfer<Args>) => E,
745
- f: (_: E, ...args: NoInfer<Args>) => F
746
- ): CommandOutHelper<Args, F, Id, I18nKey, State>
762
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
763
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
764
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
765
+ e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
766
+ f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F
767
+ ): CommandOutHelper<Arg, F, Id, I18nKey, State>
747
768
  <
748
769
  A,
749
770
  B,
@@ -759,15 +780,16 @@ export declare namespace Commander {
759
780
  EEff,
760
781
  REff
761
782
  >,
762
- ...args: NoInfer<Args>
783
+ arg: NoInfer<Arg>,
784
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
763
785
  ) => A,
764
- b: (_: A, ...args: NoInfer<Args>) => B,
765
- c: (_: B, ...args: NoInfer<Args>) => C,
766
- d: (_: C, ...args: NoInfer<Args>) => D,
767
- e: (_: D, ...args: NoInfer<Args>) => E,
768
- f: (_: E, ...args: NoInfer<Args>) => F,
769
- g: (_: F, ...args: NoInfer<Args>) => G
770
- ): CommandOutHelper<Args, G, Id, I18nKey, State>
786
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
787
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
788
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
789
+ e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
790
+ f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
791
+ g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G
792
+ ): CommandOutHelper<Arg, G, Id, I18nKey, State>
771
793
  <A, B, C, D, E, F, G, H extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
772
794
  a: (
773
795
  _: Effect.Effect<
@@ -775,16 +797,17 @@ export declare namespace Commander {
775
797
  EEff,
776
798
  REff
777
799
  >,
778
- ...args: NoInfer<Args>
800
+ arg: NoInfer<Arg>,
801
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
779
802
  ) => A,
780
- b: (_: A, ...args: NoInfer<Args>) => B,
781
- c: (_: B, ...args: NoInfer<Args>) => C,
782
- d: (_: C, ...args: NoInfer<Args>) => D,
783
- e: (_: D, ...args: NoInfer<Args>) => E,
784
- f: (_: E, ...args: NoInfer<Args>) => F,
785
- g: (_: F, ...args: NoInfer<Args>) => G,
786
- h: (_: G, ...args: NoInfer<Args>) => H
787
- ): CommandOutHelper<Args, H, Id, I18nKey, State>
803
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
804
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
805
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
806
+ e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
807
+ f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
808
+ g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
809
+ h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H
810
+ ): CommandOutHelper<Arg, H, Id, I18nKey, State>
788
811
  <A, B, C, D, E, F, G, H, I extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>>(
789
812
  a: (
790
813
  _: Effect.Effect<
@@ -792,34 +815,35 @@ export declare namespace Commander {
792
815
  EEff,
793
816
  REff
794
817
  >,
795
- ...args: NoInfer<Args>
818
+ arg: NoInfer<Arg>,
819
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
796
820
  ) => A,
797
- b: (_: A, ...args: NoInfer<Args>) => B,
798
- c: (_: B, ...args: NoInfer<Args>) => C,
799
- d: (_: C, ...args: NoInfer<Args>) => D,
800
- e: (_: D, ...args: NoInfer<Args>) => E,
801
- f: (_: E, ...args: NoInfer<Args>) => F,
802
- g: (_: F, ...args: NoInfer<Args>) => G,
803
- h: (_: G, ...args: NoInfer<Args>) => H,
804
- i: (_: H, ...args: NoInfer<Args>) => I
805
- ): CommandOutHelper<Args, I, Id, I18nKey, State>
821
+ b: (_: A, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => B,
822
+ c: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
823
+ d: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
824
+ e: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
825
+ f: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
826
+ g: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
827
+ h: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
828
+ i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I
829
+ ): CommandOutHelper<Arg, I, Id, I18nKey, State>
806
830
  }
807
831
 
808
832
  export type NonGenWrap<
809
833
  RT,
810
834
  Id extends string,
811
835
  I18nKey extends string,
812
- Args extends Array<unknown>,
836
+ Arg,
813
837
  AEff,
814
838
  EEff,
815
839
  REff,
816
840
  State extends IntlRecord | undefined
817
841
  > = {
818
- (): Exclude<REff, RT> extends never ? CommandOutHelper<Args, Effect.Effect<AEff, EEff, REff>, Id, I18nKey, State>
842
+ (): Exclude<REff, RT> extends never ? CommandOutHelper<Arg, Effect.Effect<AEff, EEff, REff>, Id, I18nKey, State>
819
843
  : MissingDependencies<RT, REff> & {}
820
844
  <
821
845
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
822
- Args extends Array<unknown>
846
+ Arg
823
847
  >(
824
848
  a: (
825
849
  _: Effect.Effect<
@@ -827,13 +851,14 @@ export declare namespace Commander {
827
851
  EEff,
828
852
  REff
829
853
  >,
830
- ...args: NoInfer<Args>
854
+ arg: NoInfer<Arg>,
855
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
831
856
  ) => Eff
832
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
857
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
833
858
  <
834
859
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
835
860
  B,
836
- Args extends Array<unknown>
861
+ Arg
837
862
  >(
838
863
  a: (
839
864
  _: Effect.Effect<
@@ -841,15 +866,16 @@ export declare namespace Commander {
841
866
  EEff,
842
867
  REff
843
868
  >,
844
- ...args: NoInfer<Args>
869
+ arg: NoInfer<Arg>,
870
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
845
871
  ) => B,
846
- b: (_: B, ...args: NoInfer<Args>) => Eff
847
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
872
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
873
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
848
874
  <
849
875
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
850
876
  B,
851
877
  C,
852
- Args extends Array<unknown>
878
+ Arg
853
879
  >(
854
880
  a: (
855
881
  _: Effect.Effect<
@@ -857,17 +883,18 @@ export declare namespace Commander {
857
883
  EEff,
858
884
  REff
859
885
  >,
860
- ...args: NoInfer<Args>
886
+ arg: NoInfer<Arg>,
887
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
861
888
  ) => B,
862
- b: (_: B, ...args: NoInfer<Args>) => C,
863
- c: (_: C, ...args: NoInfer<Args>) => Eff
864
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
889
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
890
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
891
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
865
892
  <
866
893
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
867
894
  B,
868
895
  C,
869
896
  D,
870
- Args extends Array<unknown>
897
+ Arg
871
898
  >(
872
899
  a: (
873
900
  _: Effect.Effect<
@@ -875,19 +902,20 @@ export declare namespace Commander {
875
902
  EEff,
876
903
  REff
877
904
  >,
878
- ...args: NoInfer<Args>
905
+ arg: NoInfer<Arg>,
906
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
879
907
  ) => B,
880
- b: (_: B, ...args: NoInfer<Args>) => C,
881
- c: (_: C, ...args: NoInfer<Args>) => D,
882
- d: (_: D, ...args: NoInfer<Args>) => Eff
883
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
908
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
909
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
910
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
911
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
884
912
  <
885
913
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
886
914
  B,
887
915
  C,
888
916
  D,
889
917
  E,
890
- Args extends Array<unknown>
918
+ Arg
891
919
  >(
892
920
  a: (
893
921
  _: Effect.Effect<
@@ -895,13 +923,14 @@ export declare namespace Commander {
895
923
  EEff,
896
924
  REff
897
925
  >,
898
- ...args: NoInfer<Args>
926
+ arg: NoInfer<Arg>,
927
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
899
928
  ) => B,
900
- b: (_: B, ...args: NoInfer<Args>) => C,
901
- c: (_: C, ...args: NoInfer<Args>) => D,
902
- d: (_: D, ...args: NoInfer<Args>) => E,
903
- e: (_: E, ...args: NoInfer<Args>) => Eff
904
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
929
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
930
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
931
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
932
+ e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
933
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
905
934
  <
906
935
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
907
936
  B,
@@ -909,7 +938,7 @@ export declare namespace Commander {
909
938
  D,
910
939
  E,
911
940
  F,
912
- Args extends Array<unknown>
941
+ Arg
913
942
  >(
914
943
  a: (
915
944
  _: Effect.Effect<
@@ -917,14 +946,15 @@ export declare namespace Commander {
917
946
  EEff,
918
947
  REff
919
948
  >,
920
- ...args: NoInfer<Args>
949
+ arg: NoInfer<Arg>,
950
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
921
951
  ) => B,
922
- b: (_: B, ...args: NoInfer<Args>) => C,
923
- c: (_: C, ...args: NoInfer<Args>) => D,
924
- d: (_: D, ...args: NoInfer<Args>) => E,
925
- e: (_: E, ...args: NoInfer<Args>) => F,
926
- f: (_: F, ...args: NoInfer<Args>) => Eff
927
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
952
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
953
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
954
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
955
+ e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
956
+ f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
957
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
928
958
  <
929
959
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
930
960
  B,
@@ -933,7 +963,7 @@ export declare namespace Commander {
933
963
  E,
934
964
  F,
935
965
  G,
936
- Args extends Array<unknown>
966
+ Arg
937
967
  >(
938
968
  a: (
939
969
  _: Effect.Effect<
@@ -941,15 +971,16 @@ export declare namespace Commander {
941
971
  EEff,
942
972
  REff
943
973
  >,
944
- ...args: NoInfer<Args>
974
+ arg: NoInfer<Arg>,
975
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
945
976
  ) => B,
946
- b: (_: B, ...args: NoInfer<Args>) => C,
947
- c: (_: C, ...args: NoInfer<Args>) => D,
948
- d: (_: D, ...args: NoInfer<Args>) => E,
949
- e: (_: E, ...args: NoInfer<Args>) => F,
950
- f: (_: F, ...args: NoInfer<Args>) => G,
951
- g: (_: G, ...args: NoInfer<Args>) => Eff
952
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
977
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
978
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
979
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
980
+ e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
981
+ f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
982
+ g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
983
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
953
984
  <
954
985
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
955
986
  B,
@@ -959,7 +990,7 @@ export declare namespace Commander {
959
990
  F,
960
991
  G,
961
992
  H,
962
- Args extends Array<unknown>
993
+ Arg
963
994
  >(
964
995
  a: (
965
996
  _: Effect.Effect<
@@ -967,16 +998,17 @@ export declare namespace Commander {
967
998
  EEff,
968
999
  REff
969
1000
  >,
970
- ...args: NoInfer<Args>
1001
+ arg: NoInfer<Arg>,
1002
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
971
1003
  ) => B,
972
- b: (_: B, ...args: NoInfer<Args>) => C,
973
- c: (_: C, ...args: NoInfer<Args>) => D,
974
- d: (_: D, ...args: NoInfer<Args>) => E,
975
- e: (_: E, ...args: NoInfer<Args>) => F,
976
- f: (_: F, ...args: NoInfer<Args>) => G,
977
- g: (_: G, ...args: NoInfer<Args>) => H,
978
- h: (_: H, ...args: NoInfer<Args>) => Eff
979
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
1004
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
1005
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
1006
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
1007
+ e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
1008
+ f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
1009
+ g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
1010
+ h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
1011
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
980
1012
  <
981
1013
  Eff extends Effect.Effect<any, any, RT | CommandContext | `Commander.Command.${Id}.state`>,
982
1014
  B,
@@ -987,7 +1019,7 @@ export declare namespace Commander {
987
1019
  G,
988
1020
  H,
989
1021
  I,
990
- Args extends Array<unknown>
1022
+ Arg
991
1023
  >(
992
1024
  a: (
993
1025
  _: Effect.Effect<
@@ -995,17 +1027,18 @@ export declare namespace Commander {
995
1027
  EEff,
996
1028
  REff
997
1029
  >,
998
- ...args: NoInfer<Args>
1030
+ arg: NoInfer<Arg>,
1031
+ ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>
999
1032
  ) => B,
1000
- b: (_: B, ...args: NoInfer<Args>) => C,
1001
- c: (_: C, ...args: NoInfer<Args>) => D,
1002
- d: (_: D, ...args: NoInfer<Args>) => E,
1003
- e: (_: E, ...args: NoInfer<Args>) => F,
1004
- f: (_: F, ...args: NoInfer<Args>) => G,
1005
- g: (_: G, ...args: NoInfer<Args>) => H,
1006
- h: (_: H, ...args: NoInfer<Args>) => I,
1007
- i: (_: H, ...args: NoInfer<Args>) => Eff
1008
- ): CommandOutHelper<Args, Eff, Id, I18nKey, State>
1033
+ b: (_: B, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => C,
1034
+ c: (_: C, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => D,
1035
+ d: (_: D, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => E,
1036
+ e: (_: E, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => F,
1037
+ f: (_: F, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => G,
1038
+ g: (_: G, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => H,
1039
+ h: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => I,
1040
+ i: (_: H, arg: NoInfer<Arg>, ctx: CommandContextLocal2<NoInfer<Id>, NoInfer<I18nKey>, NoInfer<State>>) => Eff
1041
+ ): CommandOutHelper<Arg, Eff, Id, I18nKey, State>
1009
1042
  }
1010
1043
  }
1011
1044
 
@@ -1308,8 +1341,8 @@ export class CommanderImpl<RT> {
1308
1341
  const state = getStateValues(options)
1309
1342
 
1310
1343
  return Object.assign(
1311
- <Args extends ReadonlyArray<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
1312
- handler: (...args: Args) => Effect.Effect<A, E, R>
1344
+ <Arg, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
1345
+ handler: (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
1313
1346
  ) => {
1314
1347
  // we capture the definition stack here, so we can append it to later stack traces
1315
1348
  const limit = Error.stackTraceLimit
@@ -1387,7 +1420,7 @@ export class CommanderImpl<RT> {
1387
1420
  const exec = options?.disableSharedWaiting
1388
1421
  ? exec_
1389
1422
  : Effect
1390
- .fnUntraced(function*(...args: Args) {
1423
+ .fnUntraced(function*(...args: [any, any]) {
1391
1424
  registerWait(id)
1392
1425
  return yield* exec_(...args)
1393
1426
  }, Effect.onExit(() => Effect.sync(() => unregisterWait(id))))
@@ -1396,7 +1429,7 @@ export class CommanderImpl<RT> {
1396
1429
  ? computed(() => result.value.waiting)
1397
1430
  : computed(() => result.value.waiting || (waitState.value[id] ?? 0) > 0)
1398
1431
 
1399
- const handle = Object.assign((...args: Args) => {
1432
+ const handle = Object.assign((arg: Arg) => {
1400
1433
  // we capture the call site stack here
1401
1434
  const limit = Error.stackTraceLimit
1402
1435
  Error.stackTraceLimit = 2
@@ -1429,12 +1462,12 @@ export class CommanderImpl<RT> {
1429
1462
 
1430
1463
  const command = currentState.pipe(Effect.flatMap((state) =>
1431
1464
  Effect.withSpan(
1432
- exec(...args),
1465
+ exec(arg, { ...context.value, state } as any),
1433
1466
  id,
1434
1467
  {
1435
1468
  captureStackTrace,
1436
1469
  attributes: {
1437
- input: args,
1470
+ input: arg,
1438
1471
  state,
1439
1472
  action: initialContext.action,
1440
1473
  label: initialContext.label,
@@ -1595,10 +1628,10 @@ export class CommanderImpl<RT> {
1595
1628
  }
1596
1629
  )
1597
1630
 
1598
- /** @experimental */
1631
+ /** @experimental @deprecated */
1599
1632
  alt2: <
1600
1633
  const Id extends string,
1601
- MutArgs extends Array<unknown>,
1634
+ MutArg,
1602
1635
  MutA,
1603
1636
  MutE,
1604
1637
  MutR,
@@ -1607,19 +1640,19 @@ export class CommanderImpl<RT> {
1607
1640
  >(
1608
1641
  id:
1609
1642
  | Id
1610
- | { id: Id; mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR> }
1611
- | ((...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>) & { id: Id },
1643
+ | { id: Id; mutate: (arg: MutArg) => Effect.Effect<MutA, MutE, MutR> }
1644
+ | ((arg: MutArg) => Effect.Effect<MutA, MutE, MutR>) & { id: Id },
1612
1645
  options?: FnOptions<I18nKey, State>
1613
1646
  ) =>
1614
1647
  & Commander.CommandContextLocal<Id, I18nKey>
1615
- & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
1648
+ & (<A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(
1616
1649
  handler: (
1617
1650
  ctx: Effect.fn.Gen & Effect.fn.NonGen & Commander.CommandContextLocal<Id, I18nKey> & {
1618
1651
  // todo: only if we passed in one
1619
- mutate: (...args: MutArgs) => Effect.Effect<MutA, MutE, MutR>
1652
+ mutate: (arg: Arg) => Effect.Effect<MutA, MutE, MutR>
1620
1653
  }
1621
- ) => (...args: Args) => Effect.Effect<A, E, R>
1622
- ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey, State>) = (
1654
+ ) => (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
1655
+ ) => Commander.CommandOut<Arg, A, E, R, Id, I18nKey, State>) = (
1623
1656
  _id,
1624
1657
  options?
1625
1658
  ) => {
@@ -1657,9 +1690,9 @@ export class CommanderImpl<RT> {
1657
1690
  customI18nKey?: I18nKey
1658
1691
  ) =>
1659
1692
  & Commander.CommandContextLocal<Id, I18nKey>
1660
- & (<Args extends Array<unknown>, A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`>(
1661
- handler: (...args: Args) => Effect.Effect<A, E, R>
1662
- ) => Commander.CommandOut<Args, A, E, R, Id, I18nKey, State>)
1693
+ & (<A, E, R extends RT | CommandContext | `Commander.Command.${Id}.state`, Arg = void>(
1694
+ handler: (arg: Arg, ctx: Commander.CommandContextLocal2<Id, I18nKey, State>) => Effect.Effect<A, E, R>
1695
+ ) => Commander.CommandOut<Arg, A, E, R, Id, I18nKey, State>)
1663
1696
 
1664
1697
  /**
1665
1698
  * Define a Command for handling user actions with built-in error reporting and state management.
@@ -1690,7 +1723,7 @@ export class CommanderImpl<RT> {
1690
1723
  */
1691
1724
  wrap = <
1692
1725
  const Id extends string,
1693
- Args extends Array<unknown>,
1726
+ Arg,
1694
1727
  A,
1695
1728
  E,
1696
1729
  R,
@@ -1698,10 +1731,10 @@ export class CommanderImpl<RT> {
1698
1731
  I18nKey extends string = Id
1699
1732
  >(
1700
1733
  mutation:
1701
- | { mutate: (...args: Args) => Effect.Effect<A, E, R>; id: Id }
1702
- | ((...args: Args) => Effect.Effect<A, E, R>) & { id: Id },
1734
+ | { mutate: (arg: Arg) => Effect.Effect<A, E, R>; id: Id }
1735
+ | ((arg: Arg) => Effect.Effect<A, E, R>) & { id: Id },
1703
1736
  options?: FnOptions<I18nKey, State>
1704
- ): Commander.CommanderWrap<RT, Id, I18nKey, State, Args, A, E, R> =>
1737
+ ): Commander.CommanderWrap<RT, Id, I18nKey, State, Arg, A, E, R> =>
1705
1738
  Object.assign(
1706
1739
  (
1707
1740
  ...combinators: any[]
@@ -1717,8 +1750,8 @@ export class CommanderImpl<RT> {
1717
1750
  return this.makeCommand(mutation.id, options, errorDef)(
1718
1751
  Effect.fnUntraced(
1719
1752
  // fnUntraced only supports generators as first arg, so we convert to generator if needed
1720
- isGeneratorFunction(mutate) ? mutate : function*(...args: Args) {
1721
- return yield* mutate(...args)
1753
+ isGeneratorFunction(mutate) ? mutate : function*(arg: Arg) {
1754
+ return yield* mutate(arg)
1722
1755
  },
1723
1756
  ...combinators as [any]
1724
1757
  ) as any