import { z } from 'zod';
import { ArgsObject } from './command';
export declare const OptionConfig: <OptionType, Args extends ArgsObject = ArgsObject>(type: z.ZodType<OptionType>) => z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    defaultValue: z.ZodOptional<z.ZodAny>;
    aliases: z.ZodArray<z.ZodString>;
    parse: z.ZodOptional<z.ZodType<Parser<Args, OptionType>>>;
    array: z.ZodOptional<z.ZodBoolean>;
    required: z.ZodOptional<z.ZodBoolean>;
    isDefault: z.ZodOptional<z.ZodBoolean>;
    hidden: z.ZodOptional<z.ZodBoolean>;
    outputName: z.ZodOptional<z.ZodString>;
}, z.core.$strip>;
export type OptionConfig<T = unknown, Args extends ArgsObject = ArgsObject> = z.infer<ReturnType<typeof OptionConfig<T, Args>>>;
/**
 * Configuration for a flag (boolean argument) that can be passed to a command.
 */
export declare const FlagConfig: z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    defaultValue: z.ZodOptional<z.ZodAny>;
    aliases: z.ZodArray<z.ZodString>;
    array: z.ZodOptional<z.ZodBoolean>;
    required: z.ZodOptional<z.ZodBoolean>;
    hidden: z.ZodOptional<z.ZodBoolean>;
    outputName: z.ZodOptional<z.ZodString>;
    negatable: z.ZodOptional<z.ZodBoolean>;
    negationName: z.ZodOptional<z.ZodString>;
    negationAliases: z.ZodOptional<z.ZodArray<z.ZodString>>;
}, z.core.$strip>;
export type FlagConfig = z.infer<typeof FlagConfig>;
/**
 * A function that parses an option value.
 */
export type Parser<Args extends ArgsObject = ArgsObject, OptionType extends any = any> = (x: string, y: Args) => OptionType;
/** {@link OptionConfig} with a specified value type */
export declare const TypedOptionConfig: <OptionType, Args extends ArgsObject = ArgsObject>(type: z.ZodType<OptionType>) => z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    defaultValue: z.ZodOptional<z.ZodAny>;
    aliases: z.ZodArray<z.ZodString>;
    parse: z.ZodOptional<z.ZodType<Parser<Args, OptionType>, unknown, z.core.$ZodTypeInternals<Parser<Args, OptionType>, unknown>>>;
    array: z.ZodOptional<z.ZodBoolean>;
    required: z.ZodOptional<z.ZodBoolean>;
    isDefault: z.ZodOptional<z.ZodBoolean>;
    hidden: z.ZodOptional<z.ZodBoolean>;
    outputName: z.ZodOptional<z.ZodString>;
    type: z.ZodOptional<z.ZodEnum<{
        number: "number";
    }>>;
}, z.core.$strip>;
export type TypedOptionConfig<T, A extends ArgsObject = ArgsObject> = z.infer<ReturnType<typeof TypedOptionConfig<T, A>>>;
/**
 * @see OptionConfig
 * @see ArrayOptionConfig
 */
export declare const ArrayOptionConfig: <T, A extends ArgsObject = ArgsObject>(type: z.ZodType<T>) => z.ZodObject<{
    name: z.ZodString;
    description: z.ZodString;
    aliases: z.ZodArray<z.ZodString>;
    parse: z.ZodOptional<z.ZodType<Parser<A, T[]>, unknown, z.core.$ZodTypeInternals<Parser<A, T[]>, unknown>>>;
    array: z.ZodOptional<z.ZodBoolean>;
    required: z.ZodOptional<z.ZodBoolean>;
    isDefault: z.ZodOptional<z.ZodBoolean>;
    hidden: z.ZodOptional<z.ZodBoolean>;
    outputName: z.ZodOptional<z.ZodString>;
    type: z.ZodOptional<z.ZodEnum<{
        number: "number";
    }>>;
    defaultValue: z.ZodOptional<z.ZodArray<z.ZodType<T, unknown, z.core.$ZodTypeInternals<T, unknown>>>>;
}, z.core.$strip>;
/**
 * An option that can be passed to a command.
 *
 * This type represents an array option, which can be specified multiple times.
 */
export type ArrayOptionConfig<T = unknown> = z.infer<ReturnType<typeof ArrayOptionConfig<z.ZodType<T>>>>;
/** The default prefixes for options */
export declare const DEFAULT_OPT_FULL_PREFIX = "--";
/** The default prefix for option aliases */
export declare const DEFAULT_OPT_SHORT_PREFIX = "-";
export type Prefixes = {
    normalPrefix: string;
    aliasPrefix: string;
};
export type Names = {
    name: string;
    aliases: string[];
};
/** Names with prefixes built-in */
export type QualifiedNames = {
    name: string;
    aliases: string[];
    negationName: string;
    negationAliases: string[];
};
/** @internal */
export type ArgvValue<T> = {
    argv: string[];
    value: T;
    key: string;
};
/**
 * An option that can be passed to a command.
 *
 * Options can be specified in two ways:
 *
 * - Using the long form, e.g. `--option value`
 * - Using the short form, e.g. `-o value`
 *
 * They can also have a parse function, which will be used to parse the value passed in from the
 * original argument (string).
 *
 * @example
 * ```ts
 * massarg(options).option({
 *   name: 'option',
 *   description: 'An option',
 *   defaultValue: 'default',
 *   aliases: ['o'],
 *   parse: (value) => value.toUpperCase(),
 * })
 * ```
 */
export declare class MassargOption<OptionType extends any = unknown, Args extends ArgsObject = ArgsObject> implements OptionConfig<OptionType, Args> {
    name: string;
    description: string;
    defaultValue?: OptionType;
    aliases: string[];
    parse: Parser<Args, OptionType>;
    /**
     * Whether this option can be used multiple times. Any passed values will end up in an array
     * instead of each usage overwriting the existing value.
     */
    isArray: boolean;
    /** Whether this option is required. Failing to specify this option will throw an error. */
    isRequired: boolean;
    isDefault: boolean;
    outputName?: string;
    constructor(options: OptionConfig<OptionType, Args>);
    /**
     * Create a typed option from a configuration. Currently supports `number` options which
     * are automatically transformed from `string` to `number`.
     */
    static fromTypedConfig<T = unknown, A extends ArgsObject = ArgsObject>(config: TypedOptionConfig<T, A>): MassargOption<T>;
    /**
     * Returns the key which this option outputs to in the final object.
     *
     * @default The camelCase version of this option's name.
     *
     * Can be overridden with {@link outputName}.
     */
    getOutputName(): string;
    /** @internal */
    parseDetails(argv: string[], options: ArgsObject, prefixes: Prefixes): ArgvValue<OptionType>;
    /** Get the help string for this option */
    helpString(): string;
    /** Returns true if the flag (including any prefixes) matches the name or aliases */
    isMatch(arg: string, prefixes: Prefixes): boolean;
    /** Return the finalized names that will cause this option to match. */
    qualifiedNames(prefixes: Prefixes): QualifiedNames;
}
/**
 * An option that can be passed to a command.
 *
 * This type of option parses a number, and fails if it is not a valid number.
 *
 * @example
 * ```ts
 * massarg(options).option({
 *   name: 'number',
 *   description: 'A number',
 *   defaultValue: 0,
 *   aliases: ['n'],
 *   type: 'number',
 * })
 * ```
 */
export declare class MassargNumber extends MassargOption<number> {
    constructor(options: Omit<OptionConfig<number>, 'parse'>);
    parseDetails(argv: string[], options: ArgsObject, prefixes: Prefixes): ArgvValue<number>;
}
/**
 * A boolean option that can be passed to a command.
 *
 * A flag is an option that is either present or not. It can be used to toggle
 * a boolean value, or to indicate that a command should be run in a different
 * mode.
 *
 * A flag can be negated by using `negatable: true`. By default, the negated name is the same
 * as the option name, prefixed by `no-`, and each of the aliases will be uppercased.
 * For example, `--verbose` and `--no-verbose`, or `-v` and `-V`.
 * This behavior can be overridden by the `negatedName` and `negatedAliases` options.
 *
 * @example
 * ```ts
 * massarg.flag({
 *   name: 'verbose',
 *   aliases: ['v'],
 *   description: 'Enable verbose logging',
 *   defaultValue: false,
 * })
 * ```
 */
export declare class MassargFlag extends MassargOption<boolean> {
    /** Whether this flag may be negated using `negationName` or `negationAliases`. */
    negatable: boolean;
    /** The negation name of this flag, which can be used with the full option notation. */
    negationName: string;
    /** The negation aliases of this flag, which can be used with the shorthand option notation. */
    negationAliases: string[];
    constructor(options: FlagConfig);
    parseDetails(argv: string[], _options: ArgsObject, prefixes: Prefixes): ArgvValue<boolean>;
    qualifiedNames(prefixes: Prefixes): QualifiedNames;
}
/** A flag that can be passed to a command to show the help message. */
export declare class MassargHelpFlag extends MassargFlag {
    constructor(config?: Partial<Omit<OptionConfig<boolean>, 'parse'>>);
}
//# sourceMappingURL=option.d.ts.map