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

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

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

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

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

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

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

export 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>
}

export declare const mapEffect: {
  <A, B>(f: (a: A) => Effect<B, ValidationError, any>): (self: Command<A>) => Command<B>
  <A, B>(self: Command<A>, f: (a: A) => Effect<B, ValidationError, any>): Command<B>
}

export declare const parse: {
  (
    args: ReadonlyArray<string>,
    config: CliConfig
  ): <A>(self: Command<A>) => Effect<CommandDirective<A>, ValidationError, any>
  <A>(
    self: Command<A>,
    args: ReadonlyArray<string>,
    config: CliConfig
  ): Effect<CommandDirective<A>, ValidationError, any>
}

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

export declare const withSubcommands: {
  <
    const Subcommands extends readonly [
      readonly [id: unknown, command: Command<any>],
      ...(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>],
      ...(readonly [id: unknown, command: Command<any>])[]
    ]
  >(
    self: Command<A>,
    subcommands: [...Subcommands]
  ): Command<Command.ComputeParsedType<A & Readonly<{ subcommand: Option<Command.Subcommands<Subcommands>> }>>>
}

export declare const wizard: {
  (prefix: ReadonlyArray<string>, config: CliConfig): <A>(self: Command<A>) => Effect<string[], any, any>
  <A>(self: Command<A>, prefix: ReadonlyArray<string>, config: CliConfig): Effect<string[], any, any>
}

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

export 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 {}

export declare const TypeId: typeof TypeId

export type TypeId = typeof TypeId

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

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

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

export type ParsedStandardCommand<Name extends string, OptionsType, ArgsType> = Command.ComputeParsedType<{
  readonly name: Name
  readonly options: OptionsType
  readonly args: ArgsType
}>

export type ParsedUserInputCommand<Name extends string, ValueType> = Command.ComputeParsedType<{
  readonly name: Name
  readonly value: ValueType
}>

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