/**
 * Builder functions for defining CLI options and positionals.
 *
 * Provides ergonomic helpers with full TypeScript type inference for
 * constructing option schemas (`opt.string()`, `opt.boolean()`, `opt.enum()`,
 * etc.) and positional schemas (`opt.stringPos()`, `opt.numberPos()`,
 * `opt.variadic()`).
 *
 * @packageDocumentation
 */
import type { ArrayOption, BooleanOption, CountOption, EnumArrayOption, EnumOption, EnumPositional, InferOptions, InferPositionals, NumberOption, NumberPositional, OptionsSchema, Parser, PositionalDef, StringOption, StringPositional, VariadicPositional } from "./types.cjs";
/**
 * A Parser that can also be called as a function to merge with another parser.
 * This allows `opt.options()` to work both as:
 *
 * - First arg in pipe: used directly as a Parser
 * - Later arg in pipe: called as function to merge with incoming Parser
 *
 * @group Type Utilities
 * @knipignore
 */
export type CallableOptionsParser<V> = (<V2, P2 extends readonly unknown[]>(parser: Parser<V2, P2>) => Parser<V & V2, P2>) & Parser<V, readonly []>;
/**
 * Extract the inferred values type from a CallableOptionsParser or Parser.
 *
 * Useful for getting the type of global options to use elsewhere in your code.
 *
 * @example
 *
 * ```typescript
 * const globalOptions = opt.options({
 *   verbose: opt.boolean(),
 *   'output-dir': opt.string(),
 * });
 *
 * // Extract the type for use elsewhere
 * type GlobalOpts = InferParserValues<typeof globalOptions>;
 * // { verbose: boolean | undefined; 'output-dir': string | undefined }
 * ```
 *
 * @group Type Utilities
 */
export type InferParserValues<T> = T extends CallableOptionsParser<infer V> ? V : T extends Parser<infer V, readonly unknown[]> ? V : never;
/**
 * Namespaced option builders.
 *
 * @example
 *
 * ```typescript
 * import { opt } from 'bargs';
 *
 * const parser = opt.options({
 *   verbose: opt.boolean({ aliases: ['v'] }),
 *   name: opt.string({ default: 'world' }),
 *   level: opt.enum(['low', 'medium', 'high']),
 * });
 * ```
 *
 * @group Core API
 */
export declare const opt: {
    /**
     * Define an array option (--flag value --flag value2).
     *
     * @example
     *
     * ```typescript
     * // Primitive array
     * opt.array('string'); // --file a.txt --file b.txt → ['a.txt', 'b.txt']
     * opt.array('number'); // --port 80 --port 443 → [80, 443]
     *
     * // Enum array (with choices)
     * opt.array(['low', 'medium', 'high']); // --priority low --priority high
     * ```
     */
    array: {
        (items: "number" | "string", props?: Omit<ArrayOption, "items" | "type">): ArrayOption;
        <const T extends readonly string[]>(choices: T, props?: Omit<EnumArrayOption<T[number]>, "choices" | "type">): EnumArrayOption<T[number]>;
    };
    /**
     * Define a boolean option.
     *
     * @function
     */
    boolean: <P extends Omit<BooleanOption, "type"> = Omit<BooleanOption, "type">>(props?: P) => BooleanOption & P;
    /**
     * Define a count option (--verbose --verbose = 2).
     *
     * @function
     */
    count: (props?: Omit<CountOption, "type">) => CountOption;
    /**
     * Define an enum option with string choices.
     *
     * @function
     */
    enum: <const T extends readonly string[], P extends Omit<EnumOption<T[number]>, "choices" | "type"> = Omit<EnumOption<T[number]>, "type" | "choices">>(choices: T, props?: P) => EnumOption<T[number]> & P;
    /**
     * Define an enum positional argument with string choices.
     *
     * @function
     */
    enumPos: <const T extends readonly string[], P extends Omit<EnumPositional<T[number]>, "choices" | "type"> = Omit<EnumPositional<T[number]>, "type" | "choices">>(choices: T, props?: P) => EnumPositional<T[number]> & P;
    /**
     * Define a number option.
     *
     * @function
     */
    number: <P extends Omit<NumberOption, "type"> = Omit<NumberOption, "type">>(props?: P) => NumberOption & P;
    /**
     * Define a number positional argument.
     *
     * @function
     */
    numberPos: <P extends Omit<NumberPositional, "type"> = Omit<NumberPositional, "type">>(props?: P) => NumberPositional & P;
    /**
     * Create a Parser from an options schema.
     *
     * @example
     *
     * ```typescript
     * const parser = opt.options({
     *   verbose: opt.boolean({ aliases: ['v'] }),
     *   name: opt.string({ default: 'world' }),
     * });
     * // Type: Parser<{ verbose: boolean | undefined, name: string }, []>
     * ```
     */
    options: <T extends OptionsSchema>(schema: T) => CallableOptionsParser<InferOptions<T>>;
    /**
     * Define a string option.
     *
     * @function
     */
    string: <P extends Omit<StringOption, "type"> = Omit<StringOption, "type">>(props?: P) => P & StringOption;
    /**
     * Define a string positional argument.
     *
     * @function
     */
    stringPos: <P extends Omit<StringPositional, "type"> = Omit<StringPositional, "type">>(props?: P) => P & StringPositional;
    /**
     * Define a variadic positional (rest args).
     *
     * @function
     */
    variadic: (items: "number" | "string", props?: Omit<VariadicPositional, "items" | "type">) => VariadicPositional;
};
/**
 * A Parser that can also be called as a function to merge with another parser.
 * This allows `pos.positionals()` to work both as:
 *
 * - First arg in pipe: used directly as a Parser
 * - Later arg in pipe: called as function to merge with incoming Parser
 *
 * For positionals, we DON'T intersect values - we just pass through V2.
 *
 * @group Type Utilities
 * @knipignore
 */
export type CallablePositionalsParser<P extends readonly unknown[]> = (<V2, P2 extends readonly unknown[]>(parser: Parser<V2, P2>) => Parser<V2, readonly [...P2, ...P]>) & Parser<object, P>;
/**
 * Extract the inferred positionals tuple type from a CallablePositionalsParser
 * or Parser.
 *
 * @example
 *
 * ```typescript
 * const positionals = pos.positionals(
 *   pos.string({ name: 'source', required: true }),
 *   pos.string({ name: 'dest', required: true }),
 * );
 *
 * // Extract the type for use elsewhere
 * type Positionals = InferParserPositionals<typeof positionals>;
 * // readonly [string, string]
 * ```
 *
 * @group Type Utilities
 */
export type InferParserPositionals<T> = T extends CallablePositionalsParser<infer P> ? P : T extends Parser<unknown, infer P> ? P : never;
/**
 * Namespaced positional builders.
 *
 * @example
 *
 * ```typescript
 * import { pos } from 'bargs';
 *
 * const parser = pos.positionals(
 *   pos.string({ name: 'input', required: true }),
 *   pos.string({ name: 'output' }),
 * );
 * ```
 *
 * @group Core API
 */
export declare const pos: {
    /**
     * Define an enum positional argument with string choices.
     *
     * @function
     */
    enum: <const T extends readonly string[], P extends Omit<EnumPositional<T[number]>, "choices" | "type"> = Omit<EnumPositional<T[number]>, "type" | "choices">>(choices: T, props?: P) => EnumPositional<T[number]> & P;
    /**
     * Define a number positional argument.
     *
     * @function
     */
    number: <P extends Omit<NumberPositional, "type"> = Omit<NumberPositional, "type">>(props?: P) => NumberPositional & P;
    /**
     * Create a Parser from positional definitions.
     *
     * @example
     *
     * ```typescript
     * const parser = pos.positionals(
     *   pos.string({ name: 'input', required: true }),
     *   pos.string({ name: 'output' }),
     * );
     * // Type: Parser<{}, readonly [string, string | undefined]>
     * ```
     */
    positionals: {
        <A extends PositionalDef>(a: A): CallablePositionalsParser<readonly [InferPositionals<readonly [A]>[0]]>;
        <A extends PositionalDef, B extends PositionalDef>(a: A, b: B): CallablePositionalsParser<InferPositionals<readonly [A, B]>>;
        <A extends PositionalDef, B extends PositionalDef, C extends PositionalDef>(a: A, b: B, c: C): CallablePositionalsParser<InferPositionals<readonly [A, B, C]>>;
        <A extends PositionalDef, B extends PositionalDef, C extends PositionalDef, D extends PositionalDef>(a: A, b: B, c: C, d: D): CallablePositionalsParser<InferPositionals<readonly [A, B, C, D]>>;
        (...positionals: PositionalDef[]): CallablePositionalsParser<readonly unknown[]>;
    };
    /**
     * Define a string positional argument.
     *
     * @function
     */
    string: <P extends Omit<StringPositional, "type"> = Omit<StringPositional, "type">>(props?: P) => P & StringPositional;
    /**
     * Define a variadic positional (rest args).
     *
     * @function
     */
    variadic: (items: "number" | "string", props?: Omit<VariadicPositional, "items" | "type">) => VariadicPositional;
};
//# sourceMappingURL=opt.d.ts.map