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

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

declare const getHelp: <A>(self: Command<A>, config: CliConfig) => HelpDoc

declare const getNames: <A>(self: Command<A>) => HashSet<string>

declare const getSubcommands: <A>(self: Command<A>) => HashMap<string, Command<unknown>>

declare const getUsage: <A>(self: Command<A>) => Usage

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

declare const map: {
  <A, B>(f: (a: A) => B): (self: Command<A>) => Command<B>
  <A, B>(self: Command<A>, f: (a: A) => B): Command<B>
}

declare const mapEffect: {
  <A, B>(f: (a: A) => Effect<B, ValidationError, FileSystem | Path | Terminal>): (self: Command<A>) => Command<B>
  <A, B>(self: Command<A>, f: (a: A) => Effect<B, ValidationError, FileSystem | Path | Terminal>): Command<B>
}

declare const parse: {
  (
    args: ReadonlyArray<string>,
    config: CliConfig
  ): <A>(self: Command<A>) => Effect<CommandDirective<A>, ValidationError, FileSystem | Path | Terminal>
  <A>(
    self: Command<A>,
    args: ReadonlyArray<string>,
    config: CliConfig
  ): Effect<CommandDirective<A>, ValidationError, FileSystem | Path | Terminal>
}

declare const withDescription: {
  (description: string | HelpDoc): <A>(self: Command<A>) => Command<A>
  <A>(self: Command<A>, description: string | HelpDoc): Command<A>
}

declare const withSubcommands: {
  <
    const Subcommands extends readonly [
      readonly [id: unknown, command: Command<any>],
      ...Array<readonly [id: unknown, command: Command<any>]>
    ]
  >(
    subcommands: [...Subcommands]
  ): <A>(
    self: Command<A>
  ) => Command<Command.ComputeParsedType<A & Readonly<{ subcommand: Option<Command.Subcommands<Subcommands>> }>>>
  <
    A,
    const Subcommands extends readonly [
      readonly [id: unknown, command: Command<any>],
      ...Array<readonly [id: unknown, command: Command<any>]>
    ]
  >(
    self: Command<A>,
    subcommands: [...Subcommands]
  ): Command<Command.ComputeParsedType<A & Readonly<{ subcommand: Option<Command.Subcommands<Subcommands>> }>>>
}

declare const wizard: {
  (
    prefix: ReadonlyArray<string>,
    config: CliConfig
  ): <A>(self: Command<A>) => Effect<Array<string>, ValidationError | QuitException, FileSystem | Path | Terminal>
  <A>(
    self: Command<A>,
    prefix: ReadonlyArray<string>,
    config: CliConfig
  ): Effect<Array<string>, ValidationError | QuitException, FileSystem | Path | Terminal>
}

declare const make: <Name extends string, OptionsType = void, ArgsType = void>(
  name: Name,
  options?: Options<OptionsType>,
  args?: Args<ArgsType>
) => Command<{ readonly name: Name; readonly options: OptionsType; readonly args: ArgsType }>

declare const prompt: <Name extends string, A>(
  name: Name,
  prompt: Prompt<A>
) => Command<{ readonly name: Name; readonly value: A }>

export interface Command<A> extends Command.Variance<A>, Pipeable {}

declare const TypeId: unique symbol

type TypeId = typeof TypeId

export interface Variance<A> {
  readonly [TypeId]: {
    readonly _A: (_: never) => A
  }
}

type { readonly name: Name; readonly options: OptionsType; readonly args: ArgsType; } = Command.ComputeParsedType<{
    readonly name: Name
    readonly options: OptionsType
    readonly args: ArgsType
  }>

type { readonly name: Name; readonly value: ValueType; } = Command.ComputeParsedType<{
    readonly name: Name
    readonly value: ValueType
  }>

type GetParsedType<C> = C extends Command<infer P> ? P : never

type ComputeParsedType<A> = { [K in keyof A]: A[K] } extends infer X ? X : never

type Subcommands<A> = {
  [I in keyof A]: A[I] extends readonly [infer Id, Command<infer Value>] ? readonly [id: Id, value: Value] : never
}[number]