import type { ExprResult, ValidPaths } from './types.js';
import type { Get, Paths } from 'type-fest';
/**
 * A compiled condition operation ready for use in DynamoDB requests.
 *
 * @typeParam T - The entity type this condition operates on
 */
export type CompiledConditionOperation<T = unknown> = {
    type: 'condition_operation';
    expr: ExprResult;
    value?: T;
};
/**
 * A reference to another field, used for field-to-field comparisons.
 *
 * @typeParam T - The entity type this reference operates on
 */
export type FieldRef<T = unknown> = {
    readonly type: 'field_ref';
    readonly key: ValidPaths<T>;
};
/**
 * A comparison condition operation (=, <>, <, <=, >, >=).
 *
 * @typeParam T - The entity type this condition operates on
 */
export type CondOperation<T = unknown> = {
    type: 'condition_condition';
    key: ValidPaths<T>;
    op: '=' | '<>' | '<' | '<=' | '>' | '>=';
    value: unknown | FieldRef<T>;
};
/**
 * Logical AND operation combining multiple conditions.
 *
 * @typeParam T - The entity type this condition operates on
 */
export type AndOperation<T = unknown> = {
    type: 'condition_and';
    conditions: AnyCondition<T>[];
};
/**
 * Logical OR operation combining multiple conditions.
 *
 * @typeParam T - The entity type this condition operates on
 */
export type OrOperation<T = unknown> = {
    type: 'condition_or';
    conditions: AnyCondition<T>[];
};
/**
 * Condition that checks if an attribute does not exist.
 *
 * @typeParam T - The entity type this condition operates on
 */
export type AttributeNotExistsOperation<T = unknown> = {
    type: 'condition_attribute_not_exists';
    key: ValidPaths<T>;
};
/**
 * Condition that checks if an attribute exists.
 *
 * @typeParam T - The entity type this condition operates on
 */
export type AttributeExistsOperation<T = unknown> = {
    type: 'condition_attribute_exists';
    key: ValidPaths<T>;
};
/**
 * Union of all possible condition operation types.
 */
type AnyCondition<T = unknown> = CondOperation<T> | AndOperation<T> | OrOperation<T> | AttributeNotExistsOperation<T> | AttributeExistsOperation<T>;
/**
 * Any condition operation that can be used in a DynamoDB expression.
 *
 * @typeParam T - The entity type this condition operates on
 */
export type ConditionOperation<T = unknown> = AnyCondition<T>;
/**
 * Accepts either a pre-built condition or a builder callback.
 * Enables `condition: $ => $.cond(...)` shorthand.
 *
 * @typeParam T - The entity type this condition operates on
 */
export type ConditionInput<T = unknown> = ConditionOperation<T> | ((ops: ConditionOps<T>) => AnyCondition<T>);
/**
 * Valid keys for condition operations, including generic inputs.
 */
type ValidConditionKeys<T> = T extends unknown ? unknown extends T ? string : Paths<T, {
    bracketNotation: true;
}> : never;
/**
 * Operations available in the condition builder callback.
 *
 * @typeParam T - The entity type the conditions operate on
 */
export type ConditionOps<T> = {
    /** Creates a reference to another field for field-to-field comparisons */
    ref: <Key extends ValidConditionKeys<T>>(key: Key) => FieldRef<T>;
    /** Creates a comparison condition */
    cond: <Key extends ValidConditionKeys<T>>(key: Key, op: '=' | '<>' | '<' | '<=' | '>' | '>=', value: Get<T, Key> | FieldRef<T>) => CondOperation<T>;
    /** Combines conditions with logical AND */
    and: (...ops: AnyCondition<T>[]) => AndOperation<T>;
    /** Combines conditions with logical OR */
    or: (...ops: AnyCondition<T>[]) => OrOperation<T>;
    /** Checks that an attribute does not exist */
    attributeNotExists: <Key extends ValidConditionKeys<T>>(key: Key) => AttributeNotExistsOperation<T>;
    /** Checks that an attribute exists */
    attributeExists: <Key extends ValidConditionKeys<T>>(key: Key) => AttributeExistsOperation<T>;
};
/**
 * Creates a condition expression using a type-safe builder pattern.
 *
 * @typeParam T - The entity type the condition operates on
 * @param builder - Callback that receives condition operations and returns a condition
 * @returns A condition operation ready for compilation
 *
 * @example
 * ```ts
 * const condition = exprCondition<User>(({ cond, and }) =>
 *   and(
 *     cond("status", "=", "active"),
 *     cond("age", ">=", 18)
 *   )
 * );
 * ```
 */
export declare function exprCondition<T>(builder: (ops: ConditionOps<T>) => AnyCondition<T>): ConditionOperation<T>;
/**
 * Creates a filter expression using the same builder pattern as exprCondition.
 * Alias for exprCondition, used semantically for query filter expressions.
 *
 * @typeParam T - The entity type the filter operates on
 * @param builder - Callback that receives condition operations and returns a condition
 * @returns A condition operation ready for compilation
 */
export declare function exprFilter<T>(builder: (ops: ConditionOps<T>) => AnyCondition<T>): ConditionOperation<T>;
/**
 * Resolves a ConditionInput to a ConditionOperation.
 * If the input is a function, it is called via exprCondition.
 */
export declare function resolveCondition<T>(input: ConditionInput<T>): ConditionOperation<T>;
/**
 * Compiles a condition operation into a DynamoDB-ready expression.
 *
 * @typeParam T - The entity type the condition operates on
 * @param operation - The condition operation to compile
 * @returns A compiled condition with expression string and attribute maps
 */
export declare function compileConditionExpr<T>(operation: ConditionOperation<T>): CompiledConditionOperation<T>;
export {};
//# sourceMappingURL=condition.d.ts.map