export type NestedPathsIterator<Type, WalkedType> = Required<NonNullable<Type>> extends Required<WalkedType> ? [] | (string | (WalkedType extends readonly unknown[] ? ArrayIndexes : never))[] : Type extends (...args: any[]) => any ? never : Type extends string | number | boolean | Date | RegExp | Buffer | Uint8Array | {
    _bsontype: string;
} ? [] : Type extends readonly (infer EleType)[] ? [ArrayIndexes<Type>, ...NestedPathsIterator<EleType, WalkedType | Type>] | [...NestedPathsIterator<EleType, WalkedType | Type>] : Type extends object ? {
    [Key in Extract<keyof Type, string>]: [Key, ...NestedPathsIterator<Type[Key], WalkedType | Type>];
}[Extract<keyof Type, string>] | [] : [];
export type NestedPaths<Type> = NestedPathsIterator<Type, never>;
export type KeyChains<T> = Exclude<NestedPaths<T>, []> extends infer Paths ? Paths extends readonly (string | number)[] ? Paths extends readonly [infer First, ...infer Rest] ? First extends string | number ? Rest extends readonly (string | number)[] ? `${First}${Rest extends readonly [] ? "" : "."}${KeyChainsJoin<Rest>}` : never : never : "" : never : never;
type KeyChainsJoin<Paths extends readonly (string | number)[]> = Paths extends readonly [infer First, ...infer Rest] ? First extends string | number ? Rest extends readonly (string | number)[] ? `${First}${Rest extends readonly [] ? "" : "."}${KeyChainsJoin<Rest>}` : never : never : "";
export type IntegerListAsc<Len extends number = 10, Result extends readonly number[] = []> = Result["length"] extends Len ? Result : IntegerListAsc<Len, [...Result, Result["length"]]>;
export type Integer = IntegerListAsc[number];
export type ArrayIndexes<Array extends readonly any[] = readonly any[]> = number extends any[]["length"] ? Integer : any[] extends [infer Ele, ...infer RestArray] ? ArrayIndexes<RestArray> | RestArray["length"] : never;
export type Document = Record<string, any>;
export declare const parentLevelSymbol: unique symbol;
export declare const logicalOpSymbol: unique symbol;
export declare enum QueryOperator {
    EQ = "eq",
    NE = "ne",
    GT = "gt",
    GTE = "gte",
    LT = "lt",
    LTE = "lte",
    Exists = "exists",
    Contains = "contains",
    NotContains = "notContains"
}
export declare enum ReservedOperator {
    Not = "not",
    Nor = "nor",
    All = "all",
    Any = "any",
    Length = "length",
    In = "in",
    NotIn = "nin"
}
export type MaybeRegExp<T> = T extends string ? RegExp | T : T;
export type ValueAlternativeType<V> = V extends (infer E)[] ? MaybeRegExp<E> | V : MaybeRegExp<V>;
export type QueryOperatorCondition$contains<V> = V extends string ? string : any;
export type QueryOperatorConditions<V> = Partial<Record<QueryOperator.EQ | QueryOperator.NE | QueryOperator.GT | QueryOperator.GTE | QueryOperator.LT | QueryOperator.LTE, ValueAlternativeType<V>>> & Partial<Record<QueryOperator.Contains | QueryOperator.NotContains, QueryOperatorCondition$contains<V>>> & {
    [QueryOperator.Exists]?: boolean;
};
export type QueryConditions<Schema> = {
    [KeyChain in KeyChains<Schema>]?: QueryOperatorConditions<TypeAtKeyChain<Schema, KeyChain>> | ValueAlternativeType<TypeAtKeyChain<Schema, KeyChain>>;
};
export declare enum LogicalOperator {
    And = "and",
    Or = "or"
}
export type LogicalCondition<Schema> = (QueryConditions<Schema> | LogicalConditions<Schema>)[];
export type LogicalConditions<Schema> = Record<LogicalOperator, LogicalCondition<Schema>>;
export type Query<Schema> = QueryConditions<Schema> & LogicalConditions<Schema>;
export type LogicalLevelType<Schema> = {
    [logicalOpSymbol]: LogicalOperator;
    [parentLevelSymbol]: CurrentLevelType<Schema>;
} & LogicalCondition<Schema>;
export type RootLevelType<Schema> = {
    [logicalOpSymbol]?: never;
} & Query<Schema>;
export type CurrentLevelType<Schema> = RootLevelType<Schema> | LogicalLevelType<Schema>;
export interface ConditionBuilderOptions {
    ignoreUndefined?: boolean;
    keepNaN?: boolean;
}
export type RangeOptions = ConditionBuilderOptions;
export type EqOptions<OP extends QueryOperator = QueryOperator.EQ> = {
    queryOperator?: OP;
} & ConditionBuilderOptions;
export type TryConvertToInt<T extends string> = T extends `${Integer}` ? IntegerListAsc[T] : T extends `${number}` ? number : T;
export type TypeAtKey<T extends Document | readonly unknown[], K> = T extends readonly unknown[] ? K extends number ? T[K] : never : K extends keyof T ? T[K] : never;
export type ParseKeyChainToPath<KeyChain extends string, Separator extends string = "."> = KeyChain extends `${infer Key}${Separator}${infer Rest}` ? [TryConvertToInt<Key>, ...ParseKeyChainToPath<Rest>] : [TryConvertToInt<KeyChain>];
export type TypeAtKeyPath<T, KeyPath> = KeyPath extends (string | ArrayIndexes)[] ? KeyPath extends [infer Key, ...infer RestKeyPath] ? T extends readonly (infer E)[] ? Key extends ArrayIndexes<T> ? TypeAtKeyPath<TypeAtKey<T, Key>, RestKeyPath> : TypeAtKeyPath<E, KeyPath> : T extends Document ? TypeAtKeyPath<TypeAtKey<T, Key>, RestKeyPath> : never : T : never;
export type TypeAtKeyChain<T, KeyChain extends string, Separator extends string = "."> = TypeAtKeyPath<T, ParseKeyChainToPath<KeyChain, Separator>>;
export interface FieldOperators<T> {
    [QueryOperator.EQ]?: T;
    [QueryOperator.GT]?: T;
    [QueryOperator.GTE]?: T;
    [QueryOperator.LT]?: T;
    [QueryOperator.LTE]?: T;
    [QueryOperator.Contains]?: T extends string ? string : any;
    [QueryOperator.NotContains]?: T extends string ? string : any;
    [QueryOperator.NE]?: T;
    [QueryOperator.Exists]?: boolean;
}
export type FieldCondition<T> = FieldOperators<T> | T;
export interface LogicalOperators<T> {
    [LogicalOperator.And]?: NexusCondition<T>[];
    [LogicalOperator.Or]?: NexusCondition<T>[];
}
export type NexusCondition<T> = {
    [P in keyof T]?: FieldCondition<T[P]>;
} & LogicalOperators<T>;
export type Condition<T = Record<string, any>> = NexusCondition<T>;
export declare const NEXUS_STORAGE_CONDITION_BUILDER_ERROR_TYPE = "NEXUS_STORAGE_CONDITION_BUILDER";
export {};
//# sourceMappingURL=condition-type.d.ts.map