Args

declare const atLeast: {
  (times: 0): <A>(self: Args<A>) => Args<Array<A>>;
  (times: number): <A>(self: Args<A>) => Args<[A, ...Array<A>]>;
  <A>(self: Args<A>, times: 0): Args<Array<A>>;
  <A>(self: Args<A>, times: number): Args<[A, ...Array<A>]>;
};

declare const atMost: {
  (times: number): <A>(self: Args<A>) => Args<Array<A>>;
  <A>(self: Args<A>, times: number): Args<Array<A>>;
};

declare const between: {
  (min: 0, max: number): <A>(self: Args<A>) => Args<Array<A>>;
  (min: number, max: number): <A>(self: Args<A>) => Args<[A, ...Array<A>]>;
  <A>(self: Args<A>, min: 0, max: number): Args<Array<A>>;
  <A>(self: Args<A>, min: number, max: number): Args<[A, ...Array<A>]>;
};

declare const getHelp: <A>(self: Args<A>) => HelpDoc;

declare const getIdentifier: <A>(self: Args<A>) => Option<string>;

declare const getMaxSize: <A>(self: Args<A>) => number;

declare const getMinSize: <A>(self: Args<A>) => number;

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

declare const optional: <A>(self: Args<A>) => Args<Option<A>>;

declare const repeated: <A>(self: Args<A>) => Args<Array<A>>;

declare const validate: {
  (args: readonly Array<string>, config: CliConfig): <A>(self: Args<A>) => Effect<[Array<string>, A], ValidationError, any>;
  <A>(self: Args<A>, args: readonly Array<string>, config: CliConfig): Effect<[Array<string>, A], ValidationError, any>;
}

declare const withDefault: {
  <B>(fallback: B): <A>(self: Args<A>) => Args<B | A>;
  <A, B>(self: Args<A>, fallback: B): Args<A | B>;
};

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

declare const withFallbackConfig: {
  <B>(config: Config<B>): <A>(self: Args<A>) => Args<B | A>;
  <A, B>(self: Args<A>, config: Config<B>): Args<A | B>;
};

declare const withSchema: {
  <A, I, B>(schema: any): (self: Args<A>) => Args<B>;
  <A, I, B>(self: Args<A>, schema: any): Args<B>;
};

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

declare const all: <Arg extends Iterable<Args<any>> | Record<string, Args<any>>>(
  arg: Arg,
) => All.Return<Arg>;

declare const boolean: (options?: Args.BaseArgsConfig) => Args<boolean>;

declare const choice: <A>(
  choices: ReadonlyArray<[string, A]>,
  config?: Args.BaseArgsConfig,
) => Args<A>;

declare const date: (config?: Args.BaseArgsConfig) => Args<globalThis.Date>;

declare const directory: (config?: Args.PathArgsConfig) => Args<string>;

declare const file: (config?: Args.PathArgsConfig) => Args<string>;

declare const fileContent: (
  config?: Args.BaseArgsConfig,
) => Args<readonly [path: string, content: Uint8Array]>;

declare const fileParse: (config?: Args.FormatArgsConfig) => Args<unknown>;

declare const fileSchema: <I, A>(
  schema: Schema<A, I, FileSystem | Path | Terminal>,
  config?: Args.FormatArgsConfig,
) => Args<A>;

declare const fileText: (
  config?: Args.BaseArgsConfig,
) => Args<readonly [path: string, content: string]>;

declare const float: (config?: Args.BaseArgsConfig) => Args<number>;

declare const integer: (config?: Args.BaseArgsConfig) => Args<number>;

declare const none: Args<void>;

declare const path: (config?: Args.PathArgsConfig) => Args<string>;

declare const redacted: (config?: Args.BaseArgsConfig) => Args<Redacted>;

declare const secret: (config?: Args.BaseArgsConfig) => Args<Secret>;

declare const text: (config?: Args.BaseArgsConfig) => Args<string>;

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

declare const mapEffect: {
  <A, B>(f: (a: A) => Effect<B, HelpDoc, any>): (self: Args<A>) => Args<B>;
  <A, B>(self: Args<A>, f: (a: A) => Effect<B, HelpDoc, any>): Args<B>;
};

declare const mapTryCatch: {
  <A, B>(f: (a: A) => B, onError: (e: unknown) => HelpDoc): (self: Args<A>) => Args<B>;
  <A, B>(self: Args<A>, f: (a: A) => B, onError: (e: unknown) => HelpDoc): Args<B>;
};

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

declare const isArgs: (u: unknown) => u is Args<unknown>;

declare const ArgsTypeId: unique symbol;

type ArgsTypeId = typeof ArgsTypeId;