import { z } from 'zod';
import { ModelDef, WhereAst } from './types';
type StringOps = {
    $eq?: string;
    $ne?: string | null;
    $in?: string[] & {
        $chunk?: ChunkCfg;
    };
    $nin?: string[] & {
        $chunk?: ChunkCfg;
    };
    $like?: string;
    $startsWith?: string;
    $endsWith?: string;
    $exists?: boolean;
};
type NumberOps = {
    $eq?: number;
    $ne?: number | null;
    $in?: number[] & {
        $chunk?: ChunkCfg;
    };
    $nin?: number[] & {
        $chunk?: ChunkCfg;
    };
    $gt?: number;
    $gte?: number;
    $lt?: number;
    $lte?: number;
    $between?: [number, number];
    $exists?: boolean;
};
type BooleanOps = {
    $eq?: boolean;
    $exists?: boolean;
};
type DateLikeOps = {
    $gt?: string | Date;
    $gte?: string | Date;
    $lt?: string | Date;
    $lte?: string | Date;
    $between?: [string | Date, string | Date];
    $exists?: boolean;
};
type NullOps = {
    $ne?: null;
} | null;
export type ChunkCfg = {
    size?: number;
    parallel?: number;
};
type Logic<T> = {
    $and?: Array<Where<T>>;
    $or?: Array<Where<T>>;
    $not?: Where<T>;
    $raw?: string;
};
export type FieldOps<T> = T extends string ? StringOps | string | NullOps : T extends number ? NumberOps | number | NullOps : T extends boolean ? BooleanOps | boolean | NullOps : T extends Date ? DateLikeOps | Date | NullOps : T extends (infer U | null) ? FieldOps<U> | null : never;
export type Where<T> = Logic<T> & Partial<Record<keyof T & string, any>>;
export interface NormalizedWhere {
    ast: WhereAst | undefined;
    chunks?: Array<{
        fieldPath: string;
        op: 'in' | 'nin';
        values: unknown[];
        cfg: ChunkCfg;
    }>;
}
export declare function normalizeWhere<TModel extends ModelDef<any>>(model: TModel, where?: Where<z.infer<TModel['schema']>>): NormalizedWhere;
export {};