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