import { QueryClient } from '@tanstack/react-query';
/**
 * Computed field definition with dependency tracking
 */
export interface ComputedFieldDef<T, TDeps extends (keyof T)[], TResult> {
    /** Field dependencies needed for computation */
    needs: TDeps;
    /** Computation function receiving only needed fields */
    compute: (data: Pick<T, TDeps[number]>) => TResult;
    /** Enable memoization for expensive computations */
    cache?: boolean;
    /** Cache key function for memoization (default: JSON.stringify) */
    cacheKey?: (data: Pick<T, TDeps[number]>) => string;
}
/**
 * Result transformer function type
 */
export type ResultTransformer<T, R = T> = (result: T) => R;
/**
 * Normalization schema for nested data structures
 */
export interface NormalizationSchema<T = unknown> {
    /** Entity name for this schema */
    entity: string;
    /** ID field name (default: 'id') */
    idField?: keyof T;
    /** Nested entities to normalize */
    relations?: Record<string, NormalizationSchema>;
    /** Array fields that should be normalized */
    arrays?: (keyof T)[];
}
/**
 * Normalized data structure
 */
export interface NormalizedData<T = unknown> {
    /** Normalized entities by type */
    entities: Record<string, Record<string | number, T>>;
    /** Root result reference */
    result: string | number | (string | number)[];
}
/**
 * Field masking configuration
 */
export interface FieldMaskConfig {
    /** Fields to mask completely (removed from output) */
    remove?: string[];
    /** Fields to redact (replaced with [REDACTED]) */
    redact?: string[];
    /** Custom masking functions */
    custom?: Record<string, (value: unknown) => unknown>;
}
/**
 * Field aliasing configuration
 */
export type FieldAliases = Record<string, string>;
/**
 * Result diff operation
 */
export interface DiffOperation {
    /** Operation type */
    op: 'add' | 'remove' | 'replace' | 'update';
    /** Path to the changed value */
    path: string[];
    /** Old value (for remove/replace/update) */
    oldValue?: unknown;
    /** New value (for add/replace/update) */
    newValue?: unknown;
}
/**
 * Result diff output
 */
export interface ResultDiff {
    /** List of changes */
    changes: DiffOperation[];
    /** Has any changes */
    hasChanges: boolean;
    /** Number of changes */
    changeCount: number;
    /** Changed fields */
    changedFields: Set<string>;
}
/**
 * Aggregation function type
 */
export type AggregationFn<T, R> = (results: T[]) => R;
/**
 * LRU cache for computed field memoization
 */
declare class MemoizationCache<T = unknown> {
    private cache;
    private maxSize;
    private maxAge;
    constructor(maxSize?: number, maxAge?: number);
    get(key: string): T | undefined;
    set(key: string, value: T): void;
    clear(): void;
    size(): number;
    stats(): {
        size: number;
        hits: number;
        avgHits: number;
    };
}
/**
 * Result enhancement engine with computed fields and transformations
 */
export declare class ResultEnhancer<T extends object = Record<string, unknown>> {
    private computedFields;
    private transformers;
    private cache;
    /**
     * Define a computed field
     */
    defineComputedField<TDeps extends (keyof T)[], TResult>(name: string, definition: ComputedFieldDef<T, TDeps, TResult>): this;
    /**
     * Add a result transformer
     */
    addTransformer<R>(transformer: ResultTransformer<T, R>): this;
    /**
     * Enhance a result with computed fields
     */
    enhance(result: T): T & Record<string, unknown>;
    /**
     * Enhance multiple results
     */
    enhanceMany(results: T[]): (T & Record<string, unknown>)[];
    /**
     * Clear memoization cache
     */
    clearCache(): void;
    /**
     * Get cache statistics
     */
    getCacheStats(): ReturnType<MemoizationCache['stats']>;
}
/**
 * Transform result using a pipeline of transformers
 */
export declare function transform<T, R = T>(result: T, ...transformers: ResultTransformer<unknown, unknown>[]): R;
/**
 * Create a transformer that maps fields
 */
export declare function mapFields<T extends object = Record<string, unknown>>(mapper: Partial<Record<keyof T, (value: unknown) => unknown>>): ResultTransformer<T>;
/**
 * Create a transformer that filters fields
 */
export declare function pickFields<T extends object = Record<string, unknown>>(fields: (keyof T)[]): ResultTransformer<T, Partial<T>>;
/**
 * Create a transformer that omits fields
 */
export declare function omitFields<T extends object = Record<string, unknown>>(fields: (keyof T)[]): ResultTransformer<T>;
/**
 * Normalize nested data structures
 */
export declare function normalize<T>(data: T, schema: NormalizationSchema<T>): NormalizedData;
/**
 * Denormalize data back to nested structure
 */
export declare function denormalize<T>(normalized: NormalizedData, schema: NormalizationSchema<T>): T | T[];
/**
 * Mask sensitive fields in results
 */
export declare function mask<T extends object = Record<string, unknown>>(result: T, config: FieldMaskConfig): T;
/**
 * Mask fields deeply (recursive)
 */
export declare function maskDeep<T>(result: T, config: FieldMaskConfig): T;
/**
 * Alias field names in result
 */
export declare function alias<T extends object = Record<string, unknown>>(result: T, aliases: FieldAliases): Record<string, unknown>;
/**
 * Aggregate multiple results
 */
export declare function aggregate<T, R>(results: T[], aggregator: AggregationFn<T, R>): R;
/**
 * Common aggregation functions
 */
export declare const aggregators: {
    /** Sum numeric field across results */
    sum: <T = Record<string, unknown>>(field: keyof T) => AggregationFn<T, number>;
    /** Average numeric field across results */
    avg: <T = Record<string, unknown>>(field: keyof T) => AggregationFn<T, number>;
    /** Find minimum value */
    min: <T = Record<string, unknown>>(field: keyof T) => AggregationFn<T, number>;
    /** Find maximum value */
    max: <T = Record<string, unknown>>(field: keyof T) => AggregationFn<T, number>;
    /** Count results */
    count: <T>() => AggregationFn<T, number>;
    /** Group by field */
    groupBy: <T extends object = Record<string, unknown>>(field: keyof T) => AggregationFn<T, Record<string, T[]>>;
    /** Merge all results into one */
    merge: <T extends object = Record<string, unknown>>() => AggregationFn<T, T>;
};
/**
 * Compute diff between two results
 */
export declare function diff<T>(oldResult: T, newResult: T): ResultDiff;
/**
 * Apply a diff to a result
 */
export declare function applyDiff<T>(result: T, resultDiff: ResultDiff): T;
/**
 * React Query integration options
 */
export interface ReactQueryIntegrationOptions {
    /** Query client instance */
    queryClient: QueryClient;
    /** Auto-enhance query results */
    autoEnhance?: boolean;
    /** Result enhancer instance */
    enhancer?: ResultEnhancer<any>;
}
/**
 * Create React Query integration middleware
 */
export declare function createReactQueryMiddleware(options: ReactQueryIntegrationOptions): {
    /**
     * Enhance query data automatically
     */
    enhanceQuery<T extends object = Record<string, unknown>>(_queryKey: unknown[], data: T): T & Record<string, unknown>;
    /**
     * Invalidate queries with diff detection
     */
    invalidateWithDiff<T>(queryKey: unknown[], newData: T): Promise<void>;
    /**
     * Set query data with normalization
     */
    setNormalizedData<T>(queryKey: unknown[], data: T, schema: NormalizationSchema<T>): void;
    /**
     * Get and denormalize query data
     */
    getDenormalizedData<T>(queryKey: unknown[], schema: NormalizationSchema<T>): T | T[] | undefined;
};
/**
 * Results extension for enzyme
 */
export declare const resultsExtension: {
    readonly name: "enzyme:results";
    readonly version: "2.0.0";
    readonly description: "Comprehensive result transformations and computed fields";
    readonly client: {
        /**
         * Define a computed field for a model
         */
        readonly $defineComputedField: <T extends object = Record<string, unknown>, TDeps extends (keyof T)[] = (keyof T)[], TResult = unknown>(model: string, field: string, definition: ComputedFieldDef<T, TDeps, TResult>) => void;
        /**
         * Transform a result with multiple transformers
         */
        readonly $transform: <T, R = T>(result: T, ...transformers: ResultTransformer<unknown, unknown>[]) => R;
        /**
         * Normalize nested data
         */
        readonly $normalize: <T>(data: T, schema: NormalizationSchema<T>) => NormalizedData;
        /**
         * Denormalize data back to nested structure
         */
        readonly $denormalize: <T>(normalized: NormalizedData, schema: NormalizationSchema<T>) => T | T[];
        /**
         * Mask sensitive fields
         */
        readonly $mask: <T extends object = Record<string, unknown>>(result: T, config: FieldMaskConfig) => T;
        /**
         * Mask fields deeply (recursive)
         */
        readonly $maskDeep: <T>(result: T, config: FieldMaskConfig) => T;
        /**
         * Alias field names
         */
        readonly $alias: <T extends object = Record<string, unknown>>(result: T, aliases: FieldAliases) => Record<string, unknown>;
        /**
         * Compute diff between two results
         */
        readonly $diff: <T>(oldResult: T, newResult: T) => ResultDiff;
        /**
         * Apply a diff to a result
         */
        readonly $applyDiff: <T>(result: T, resultDiff: ResultDiff) => T;
        /**
         * Aggregate multiple results
         */
        readonly $aggregate: <T, R>(results: T[], aggregator: AggregationFn<T, R>) => R;
        /**
         * Enhance result with computed fields
         */
        readonly $enhance: <T extends object = Record<string, unknown>>(model: string, result: T) => T & Record<string, unknown>;
        /**
         * Enhance multiple results
         */
        readonly $enhanceMany: <T extends object = Record<string, unknown>>(model: string, results: T[]) => (T & Record<string, unknown>)[];
        /**
         * Clear memoization cache for a model
         */
        readonly $clearCache: (model?: string) => void;
        /**
         * Get cache statistics
         */
        readonly $getCacheStats: (model?: string) => Record<string, ReturnType<ResultEnhancer["getCacheStats"]>>;
        /**
         * Create React Query integration
         */
        readonly $createReactQueryMiddleware: (options: ReactQueryIntegrationOptions) => {
            /**
             * Enhance query data automatically
             */
            enhanceQuery<T extends object = Record<string, unknown>>(_queryKey: unknown[], data: T): T & Record<string, unknown>;
            /**
             * Invalidate queries with diff detection
             */
            invalidateWithDiff<T>(queryKey: unknown[], newData: T): Promise<void>;
            /**
             * Set query data with normalization
             */
            setNormalizedData<T>(queryKey: unknown[], data: T, schema: NormalizationSchema<T>): void;
            /**
             * Get and denormalize query data
             */
            getDenormalizedData<T>(queryKey: unknown[], schema: NormalizationSchema<T>): T | T[] | undefined;
        };
    };
    readonly utils: {
        readonly ResultEnhancer: typeof ResultEnhancer;
        readonly mapFields: typeof mapFields;
        readonly pickFields: typeof pickFields;
        readonly omitFields: typeof omitFields;
        readonly aggregators: {
            /** Sum numeric field across results */
            sum: <T = Record<string, unknown>>(field: keyof T) => AggregationFn<T, number>;
            /** Average numeric field across results */
            avg: <T = Record<string, unknown>>(field: keyof T) => AggregationFn<T, number>;
            /** Find minimum value */
            min: <T = Record<string, unknown>>(field: keyof T) => AggregationFn<T, number>;
            /** Find maximum value */
            max: <T = Record<string, unknown>>(field: keyof T) => AggregationFn<T, number>;
            /** Count results */
            count: <T>() => AggregationFn<T, number>;
            /** Group by field */
            groupBy: <T extends object = Record<string, unknown>>(field: keyof T) => AggregationFn<T, Record<string, T[]>>;
            /** Merge all results into one */
            merge: <T extends object = Record<string, unknown>>() => AggregationFn<T, T>;
        };
    };
};
/**
 * Type-safe extension type for TypeScript inference
 */
export type ResultsExtension = typeof resultsExtension;
/**
 * Extended enzyme client type with result methods
 */
export interface EnzymeClientWithResults {
    $defineComputedField: typeof resultsExtension.client.$defineComputedField;
    $transform: typeof resultsExtension.client.$transform;
    $normalize: typeof resultsExtension.client.$normalize;
    $denormalize: typeof resultsExtension.client.$denormalize;
    $mask: typeof resultsExtension.client.$mask;
    $maskDeep: typeof resultsExtension.client.$maskDeep;
    $alias: typeof resultsExtension.client.$alias;
    $diff: typeof resultsExtension.client.$diff;
    $applyDiff: typeof resultsExtension.client.$applyDiff;
    $aggregate: typeof resultsExtension.client.$aggregate;
    $enhance: typeof resultsExtension.client.$enhance;
    $enhanceMany: typeof resultsExtension.client.$enhanceMany;
    $clearCache: typeof resultsExtension.client.$clearCache;
    $getCacheStats: typeof resultsExtension.client.$getCacheStats;
    $createReactQueryMiddleware: typeof resultsExtension.client.$createReactQueryMiddleware;
}
export default resultsExtension;