import { ParsedArgumentsCollection } from "./classes";
/**
 * Represents the type of argument.
 *
 * @category Types
 */
export type ArgType = 'string' | 'number' | 'boolean';
/**
 * The type of nargs. It can be a number, or one of the following symbols:
 * - `?`: The argument is optional.
 * - `*`: The argument is optional and can appear multiple times.
 * - `+`: The argument is required and can appear multiple times.
 *
 * @category Types
 */
export type NArgs = number | '?' | '*' | '+';
/**
 * Predefined actions for the argument parser.
 *
 * @category Types
 */
export type PredefinedAction = 'version' | 'help';
/**
 * A function that takes a value and does something with it.
 *
 * @category Types
 */
export type ActionFunction = ((value: unknown, parsed: ParsedArgumentsCollection, parser: ArgsParserInterface) => void);
/**
 * An action that can be used with the argument parser.
 * It can be a predefined action or a function that takes a value
 * and does something with it.
 *
 * @category Types
 */
export type Action = PredefinedAction | ActionFunction;
/**
 * Router action function.
 */
export type RouterAction = (parser: ArgsParserInterface, args: string[]) => (void | Promise<void>);
/**
 * Configuration for the argument parser.
 *
 * @category Types
 */
export type ArgParserConfig = {
    /**
     * The name of the program.
     */
    name?: string;
    /**
     * The version of the program.
     */
    version?: string;
    /**
     * Whether to exit the program on error (true by default).
     */
    exitOnError?: boolean;
    /**
     * Whether to exit the program on StopException (true by default).
     */
    exitOnStop?: boolean;
    /**
     * Whether to ignore unrecognized arguments (false by default).
     */
    ignoreUnrecognized?: boolean;
};
/**
 * Configuration for an argument.
 *
 * @category Types
 */
export type ArgConfig = {
    /**
     * The type of the argument.
     */
    type: ArgType;
    /**
     * The name of the argument.
     */
    name: string;
    /**
     * An optional alias for the argument.
     */
    alias?: string;
    /**
     * A description of the argument.
     */
    description?: string;
    /**
     * Whether the argument is required.
     */
    nargs?: NArgs;
    /**
     * Whether the argument is required.
     */
    required?: boolean;
    /**
     * The default value of the argument.
     */
    default?: unknown;
    /**
     * A constant value for the argument.
     */
    const?: unknown;
    /**
     * Allowed values for the argument.
     */
    choices?: unknown[];
    /**
     * A custom action for the argument.
     */
    action?: Action;
    /**
     * A custom validator function for the argument value.
     */
    validator?: (value: unknown) => boolean;
};
/**
 * Configuration for an action used with the argument parser.
 *
 * @category Types
 */
export type ActionConfig = {
    /**
     * The name of the action.
     */
    name: string;
    /**
     * An optional alias for the action.
     */
    alias?: string;
    /**
     * A description of the action.
     */
    description?: string;
    /**
     * The action to be performed.
     */
    action: Action;
};
/**
 * ArgConfig extension.
 *
 * @category Types
 */
export type ArgExtraConfig = {
    /**
     * If the argument is positional.
     */
    positional: boolean;
    /**
     * If the argument is multiple.
     */
    multiple: boolean;
    /**
     * If the argument is required.
     */
    required: boolean;
    /**
     * If the argument is allowed to be empty.
     */
    allowEmpty: boolean;
    /**
     * The minimum number of times the argument is allowed to appear.
     */
    minValuesCount: number;
    /**
     * The number of times the argument is allowed to appear.
     * If not defined, it means the argument can appear any number of times.
     */
    valuesCount?: number;
};
/**
 * Extended configuration for an argument, combining both input and extra configurations.
 *
 * @category Types
 */
export type ArgConfigExtended = ArgConfig & ArgExtraConfig;
/**
 * Interface for a collection of parsed arguments.
 *
 * @category Interfaces
 */
export interface ParsedArgumentsCollectionInterface {
    /**
     * All positional arguments as a record.
     */
    readonly positional: Record<string, unknown>;
    /**
     * All optional arguments as a record.
     */
    readonly options: Record<string, unknown>;
    /**
     * Retrieves an argument value by name.
     *
     * @param name - The name of the argument.
     *
     * @returns The value of the argument.
     */
    get<T = unknown>(name: string): T;
    /**
     * Checks if an argument exists in the collection.
     *
     * @param name - The name of the argument.
     *
     * @returns True if the argument exists, false otherwise.
     */
    has(name: string): boolean;
}
/**
 * Interface for an argument parser.
 *
 * @category Interfaces
 */
export interface ArgsParserInterface {
    /**
     * The configuration of the argument parser.
     */
    readonly config: ArgParserConfig;
    /**
     * The help message for the arguments.
     */
    readonly help: string;
    /**
     * Adds an argument configuration to the parser.
     *
     * @param config - The argument configuration.
     *
     * @returns The updated parser.
     */
    addArgument(config: ArgConfig): ArgsParserInterface;
    /**
     * Adds an action configuration to the parser.
     *
     * @param config - The action configuration.
     *
     * @returns The updated parser.
     */
    addAction(config: ActionConfig): ArgsParserInterface;
    /**
     * Adds a help action to the parser.
     *
     * @param name - The name of the help action.
     * @param alias - The alias of the help action.
     *
     * @returns The updated parser.
     */
    addHelpAction(name?: string, alias?: string): ArgsParserInterface;
    /**
     * Adds a version action to the parser.
     *
     * @param name - The name of the version action.
     * @param alias - The alias of the version action.
     *
     * @returns The updated parser.
     */
    addVersionAction(name?: string, alias?: string): ArgsParserInterface;
    /**
     * Parses the given argument string and returns a collection of parsed arguments.
     *
     * @param argv - The argument string.
     *
     * @returns A ParsedArgumentsCollection containing the parsed arguments.
     */
    parse(argv: string[]): ParsedArgumentsCollectionInterface;
}
/**
 * Interface for a value validator.
 *
 * @category Interfaces
 */
export interface ValueValidatorInterface {
    /**
     * Validates the argument value before casting.
     *
     * @param value - The value to validate.
     * @param isset - Whether the value is set.
     *
     * @throws ArgumentValueError if the value is invalid.
     */
    validateBeforeCast(value: string[], isset: boolean): void;
    /**
     * Validates the argument value after casting.
     *
     * @param value - The value to validate.
     *
     * @throws ArgumentValueError if the value is invalid.
     */
    validateAfterCast(value: string[]): void;
}
/**
 * Interface for a value caster.
 *
 * @template T - The expected type of the argument value.
 *
 * @category Interfaces
 */
export interface ValueCasterInterface<T> {
    /**
     * Casts the argument value to the expected type.
     *
     * @param value - The value to cast.
     * @param isset - Whether the value is set.
     *
     * @returns The casted value.
     */
    cast(value: string[], isset: boolean): T | undefined;
}
/**
 * Interface for a router.
 *
 * @category Interfaces
 * @category Router
 */
export interface RouterInterface {
    /**
     * Runs the router.
     *
     * @param argv - The argument string.
     */
    run(argv?: string[]): void;
    /**
     * Runs the router asynchronously.
     *
     * @param argv - The argument string.
     */
    runAsync(argv?: string[]): Promise<void>;
}