Command

declare const getBashCompletions: <Name extends string, R, E, A>(self: Command<Name, R, E, A>, programName: string) => Effect<Array<string>>

declare const getFishCompletions: <Name extends string, R, E, A>(self: Command<Name, R, E, A>, programName: string) => Effect<Array<string>>

declare const getHelp: <Name extends string, R, E, A>(self: Command<Name, R, E, A>, config: CliConfig) => HelpDoc

declare const getNames: <Name extends string, R, E, A>(self: Command<Name, R, E, A>) => HashSet<string>

declare const getSubcommands: <Name extends string, R, E, A>(self: Command<Name, R, E, A>) => HashMap<string, Descriptor.Command<unknown>>

declare const getUsage: <Name extends string, R, E, A>(self: Command<Name, R, E, A>) => Usage

declare const getZshCompletions: <Name extends string, R, E, A>(self: Command<Name, R, E, A>, programName: string) => Effect<Array<string>>

declare const wizard: {
  (prefix: readonly Array<string>, config: CliConfig): <Name extends string, R, E, A>(self: Command<Name, R, E, A>) => Effect<Array<string>, any, any>;
  <Name extends string, R, E, A>(self: Command<Name, R, E, A>, prefix: readonly Array<string>, config: CliConfig): Effect<Array<string>, any, any>;
}

declare const provide: {
  <A, LR, LE, LA>(layer: Layer<LA, LE, LR> | (_: A) => Layer<LA, LE, LR>): <Name extends string, R, E>(self: Command<Name, R, E, A>) => Command<Name, LR | Exclude<R, LA>, LE | E, A>;
  <Name extends string, R, E, A, LR, LE, LA>(self: Command<Name, R, E, A>, layer: Layer<LA, LE, LR> | (_: A) => Layer<LA, LE, LR>): Command<Name, LR | Exclude<R, LA>, E | LE, A>;
}

declare const provideEffect: {
  <I, S, A, R2, E2>(tag: Tag<I, S>, effect: Effect<S, E2, R2> | (_: A) => Effect<S, E2, R2>): <Name extends string, R, E>(self: Command<Name, R, E, A>) => Command<Name, R2 | Exclude<R, I>, E2 | E, A>;
  <Name extends string, R, E, A, I, S, R2, E2>(self: Command<Name, R, E, A>, tag: Tag<I, S>, effect: Effect<S, E2, R2> | (_: A) => Effect<S, E2, R2>): Command<Name, R2 | Exclude<R, I>, E | E2, A>;
}

declare const provideEffectDiscard: {
  <A, R2, E2, _>(effect: Effect<_, E2, R2> | (_: A) => Effect<_, E2, R2>): <Name extends string, R, E>(self: Command<Name, R, E, A>) => Command<Name, R2 | R, E2 | E, A>;
  <Name extends string, R, E, A, R2, E2, _>(self: Command<Name, R, E, A>, effect: Effect<_, E2, R2> | (_: A) => Effect<_, E2, R2>): Command<Name, R | R2, E | E2, A>;
}

declare const provideSync: {
  <I, S, A>(tag: Tag<I, S>, service: S | (_: A) => S): <Name extends string, R, E>(self: Command<Name, R, E, A>) => Command<Name, Exclude<R, I>, E, A>;
  <Name extends string, R, E, A, I, S>(self: Command<Name, R, E, A>, tag: Tag<I, S>, service: S | (_: A) => S): Command<Name, Exclude<R, I>, E, A>;
}

declare const transformHandler: {
  <R, E, A, R2, E2>(f: (effect: Effect<void, E, R>, config: A) => Effect<void, E2, R2>): <Name extends string>(self: Command<Name, R, E, A>) => Command<Name, R | R2, E | E2, A>;
  <Name extends string, R, E, A, R2, E2>(self: Command<Name, R, E, A>, f: (effect: Effect<void, E, R>, config: A) => Effect<void, E2, R2>): Command<Name, R | R2, E | E2, A>;
}

declare const withDescription: {
  (help: string | HelpDoc): <Name extends string, R, E, A>(self: Command<Name, R, E, A>) => Command<Name, R, E, A>;
  <Name extends string, R, E, A>(self: Command<Name, R, E, A>, help: string | HelpDoc): Command<Name, R, E, A>;
}

declare const withHandler: {
  <A, R, E>(handler: (_: A) => Effect<void, E, R>): <Name extends string, XR, XE>(self: Command<Name, XR, XE, A>) => Command<Name, R, E, A>;
  <Name extends string, XR, XE, A, R, E>(self: Command<Name, XR, XE, A>, handler: (_: A) => Effect<void, E, R>): Command<Name, R, E, A>;
}

declare const withSubcommands: {
  <Subcommand extends readonly [Command<any, any, any, any>, Command<any, any, any, any>]>(subcommands: Subcommand): <Name extends string, R, E, A>(self: Command<Name, R, E, A>) => Command<Name, any, any, ComputeParsedType<A & Readonly<{
    subcommand: Option<Descriptor.Command.GetParsedType<...[...]["descriptor"]>>;
  }>>>;
  <Name extends string, R, E, A, Subcommand extends readonly [Command<any, any, any, any>, Command<any, any, any, any>]>(self: Command<Name, R, E, A>, subcommands: Subcommand): Command<Name, any, any, ComputeParsedType<A & Readonly<{
    subcommand: Option<Descriptor.Command.GetParsedType<Subcommand[number]["descriptor"]>>;
  }>>>;
}

declare const fromDescriptor: {
  (): <A extends {
    readonly name: string;
  }>(command: Command<A>) => Command<A["name"], never, never, A>;
  <A extends {
    readonly name: string;
  }, R, E>(handler: (_: A) => Effect<void, E, R>): (command: Command<A>) => Command<A["name"], R, E, A>;
  <A extends {
    readonly name: string;
  }>(descriptor: Command<A>): Command<A["name"], never, never, A>;
  <A extends {
    readonly name: string;
  }, R, E>(descriptor: Command<A>, handler: (_: A) => Effect<void, E, R>): Command<A["name"], R, E, A>;
}

declare const make: {
  <Name extends string>(name: Name): Command<Name, never, never, {}>;
  <Name extends string, Config extends Config>(name: Name, config: Config): Command<Name, never, never, Simplify<Simplify<{ [Key in string | number | symbol]: ParseConfigValue<Config[Key]> }>>>;
  <Name extends string, Config extends Config, R, E>(name: Name, config: Config, handler: (_: Simplify<Simplify<{ [Key in string | number | symbol]: ParseConfigValue<Config[Key]> }>>) => Effect<void, E, R>): Command<Name, R, E, Simplify<Simplify<{ [Key in string | number | symbol]: ParseConfigValue<Config[Key]> }>>>;
}

declare const prompt: <Name extends string, A, R, E>(name: Name, prompt: Prompt<A>, handler: (_: A) => Effect<void, E, R>) => Command<string, R, E, A>

declare const run: {
  (config: Omit<CliApp.ConstructorArgs<never>, "command">): <Name extends string, R, E, A>(self: Command<Name, R, E, A>) => (args: readonly Array<string>) => Effect<void, ValidationError | E, any>;
  <Name extends string, R, E, A>(self: Command<Name, R, E, A>, config: Omit<CliApp.ConstructorArgs<never>, "command">): (args: readonly Array<string>) => Effect<void, ValidationError | E, any>;
}

interface Command<Name extends string, R, E, A> extends Pipeable, Effect<A, never, Command.Context<Name>> {
  readonly [TypeId]: typeof TypeId;
  readonly descriptor: Command<A>;
  readonly handler: (_: A) => Effect<void, E, R>;
  readonly tag: Tag<Context<Name>, A>;
  readonly transform: Transform<R, E, A>;
}

declare const TypeId: unique symbol

type TypeId = typeof TypeId