/**
 * Parameter normalization utility for handling LLM-generated parameter inconsistencies.
 * Provides bidirectional snake_case/camelCase fallback inspired by CoPlay's ToolParams.
 */
export declare class ParamNormalizer {
    private params;
    constructor(params: Record<string, unknown>);
    /**
     * Get parameter with case-insensitive fallback.
     * Tries exact match first, then opposite case.
     */
    get<T = unknown>(key: string, defaultValue?: T): T | undefined;
    /**
     * Get required parameter or throw descriptive error.
     */
    getRequired<T = unknown>(key: string, errorMsg?: string): T;
    /**
     * Get boolean with string coercion ("true" -> true).
     */
    getBool(key: string, defaultValue?: boolean): boolean;
    /**
     * Get integer with string parsing and validation.
     */
    getInt(key: string, defaultValue?: number): number | undefined;
    /**
     * Check if parameter exists (with case fallback).
     */
    has(key: string): boolean;
    /**
     * Get raw value (for objects/arrays) with case fallback.
     */
    getRaw(key: string): unknown;
    private toOppositeCase;
}
/**
 * Result type for parameter validation operations.
 */
export declare class Result<T> {
    readonly isSuccess: boolean;
    readonly value: T | null;
    readonly errorMessage: string | null;
    constructor(isSuccess: boolean, value: T | null, errorMessage: string | null);
    static Success<T>(value: T): Result<T>;
    static Error<T>(message: string): Result<T>;
    /**
     * Extract value or return error response object.
     */
    getOrError(outValue: {
        value?: T;
    }): {
        error: string;
    } | null;
}
//# sourceMappingURL=params.d.ts.map