CommandDescriptor

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, any>): (self: Command<A>) => Command<B>;
  <A, B>(self: Command<A>, f: (a: A) => Effect<B, ValidationError, any>): Command<B>;
};

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

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

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

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

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

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

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

declare const TypeId: unique symbol;

type TypeId = typeof TypeId;