export interface FlagDef {
    name: string;
    type: 'boolean' | 'string' | 'string[]';
    description: string;
    placeholder?: string;
    negation?: boolean;
}
export type ParsedFlags = Record<string, string | string[] | boolean | undefined>;
type FlagTypeMap = {
    boolean: boolean | undefined;
    string: string | undefined;
    'string[]': string[] | undefined;
};
export type InferFlags<T extends readonly FlagDef[]> = {
    [K in T[number] as K['name']]: FlagTypeMap[K['type']];
};
export declare function defineFlags<const T extends readonly FlagDef[]>(defs: T): T;
export declare function typedFlags<const T extends readonly FlagDef[]>(flags: ParsedFlags, _defs: T): InferFlags<T>;
export declare class UnknownFlagError extends Error {
    readonly flag: string;
    constructor(flag: string);
}
export declare class MissingFlagValueError extends Error {
    readonly flag: string;
    constructor(flag: string);
}
export interface FlagMappingEntry {
    key: string;
    coerce?: (value: string) => unknown;
}
export type FlagMapping = Record<string, FlagMappingEntry>;
export declare function mapFlags(flags: ParsedFlags, mapping: FlagMapping): Record<string, unknown>;
/** Minimal interface compatible with Zod's safeParse — avoids a zod dependency in core. */
export interface SafeParseable<T> {
    safeParse(data: unknown): {
        success: true;
        data: T;
    } | {
        success: false;
        error: {
            issues: Array<{
                path: PropertyKey[];
                message: string;
            }>;
        };
    };
}
/**
 * Layer plugin-factory options under parsed data so registration-time defaults
 * apply wherever the schema is evaluated (command dispatch, hooks).
 */
export declare function withFactoryDefaults<T>(schema: SafeParseable<T>, defaults: Record<string, unknown>): SafeParseable<T>;
/**
 * Two-layer option resolution: registration options → CLI flags.
 * Merges sources, validates through a schema, and throws ErrorClass on failure.
 */
export declare function resolveOptions<T>(schema: SafeParseable<T>, options: Record<string, unknown>, flags: ParsedFlags, flagMapping: FlagMapping, ErrorClass?: new (message: string) => Error): T;
export declare function parseFlags<const T extends readonly FlagDef[]>(argv: string[], flagDefs: T): InferFlags<T>;
export {};
//# sourceMappingURL=flags.d.ts.map