import type { ExprResult, ValidPaths, ValidPathsWithCond } from './types.js';
import type { Get } from 'type-fest';
/**
 * A compiled update operation ready for use in DynamoDB requests.
 *
 * @typeParam T - The entity type this update operates on
 */
export type CompiledUpdateOperation<T = unknown> = {
    type: 'update_operation';
    exprResult: ExprResult;
    value?: T;
};
/**
 * A SET operation that assigns a value to an attribute.
 *
 * @typeParam T - The entity type
 * @typeParam Key - The path to the attribute being set
 */
export type SetOperation<T, Key extends ValidPaths<T> = ValidPaths<T>> = {
    type: 'update_set_value';
    key: Key;
    value: Get<T, Key> | (Get<T, Key> extends number ? AddOp<T> : never) | IfNotExistsOp<T, Key>;
};
/**
 * An arithmetic add operation for numeric attributes.
 *
 * @typeParam T - The entity type
 */
type AddOp<T> = {
    type: 'update_primitive_add_op';
    key: ValidPathsWithCond<T, number>;
    value: number;
};
/**
 * A conditional set operation that only sets if the attribute doesn't exist.
 *
 * @typeParam T - The entity type
 * @typeParam Key - The path to the attribute
 */
type IfNotExistsOp<T, Key extends ValidPaths<T> = ValidPaths<T>> = {
    type: 'update_if_not_exists_op';
    key: Key;
    value: Get<T, Key>;
};
/**
 * An operation that appends values to a list attribute.
 *
 * @typeParam T - The entity type
 * @typeParam Path - The path to the list attribute
 */
type SetAppendOperation<T, Path extends ValidPathsWithCond<T, readonly unknown[]> = ValidPathsWithCond<T, readonly unknown[]>> = {
    type: 'update_set_append';
    key: Path;
    value: Get<T, Path>;
};
/**
 * An operation that prepends values to a list attribute.
 *
 * @typeParam T - The entity type
 * @typeParam Path - The path to the list attribute
 */
type SetPrependOperation<T, Path extends ValidPathsWithCond<T, readonly unknown[]> = ValidPathsWithCond<T, readonly unknown[]>> = {
    type: 'update_set_prepend';
    key: Path;
    value: Get<T, Path>;
};
/**
 * Union of all possible update operation types.
 */
export type AnyOperation<T> = SetOperation<T> | SetAppendOperation<T> | SetPrependOperation<T> | UpdateOperation<T>;
/**
 * An array of update operations to be applied together.
 *
 * @typeParam T - The entity type this update operates on
 */
export type UpdateOperation<T = unknown> = AnyOperation<T>[];
/**
 * Operations available in the update builder callback.
 *
 * @typeParam T - The entity type the updates operate on
 */
export type UpdateOps<T> = {
    /** Sets an attribute to a value, optionally with add or if_not_exists modifiers */
    set: <Key extends ValidPaths<T>>(key: Key, value: Get<T, Key> | (Get<T, Key> extends number ? AddOp<T> : never) | IfNotExistsOp<T, Key>) => SetOperation<T, Key>;
    /** Creates an add operation for incrementing numeric attributes */
    opAdd: (key: ValidPathsWithCond<T, number>, value: number) => AddOp<T>;
    /** Creates an if_not_exists operation for conditional setting */
    opIfNotExists: <Key extends ValidPaths<T>>(key: Key, value: Get<T, Key>) => IfNotExistsOp<T, Key>;
    /** Appends values to the end of a list attribute */
    append: <Path extends ValidPathsWithCond<T, readonly unknown[]>>(key: Path, value: Get<T, Path>) => SetAppendOperation<T, Path>;
    /** Prepends values to the beginning of a list attribute */
    prepend: <Path extends ValidPathsWithCond<T, readonly unknown[]>>(key: Path, value: Get<T, Path>) => SetPrependOperation<T, Path>;
};
/**
 * Creates an add operation for incrementing a numeric attribute.
 *
 * @typeParam T - The entity type
 * @param key - Path to the numeric attribute
 * @param value - Amount to add (can be negative for subtraction)
 * @returns An AddOp to use with set()
 */
export declare function opAdd<T>(key: ValidPathsWithCond<T, number>, value: number): AddOp<T>;
/**
 * Creates an if_not_exists operation for conditional attribute setting.
 *
 * @typeParam T - The entity type
 * @typeParam Key - The path to the attribute
 * @param key - Path to the attribute
 * @param value - Default value if attribute doesn't exist
 * @returns An IfNotExistsOp to use with set()
 */
export declare function opIfNotExists<T, Key extends ValidPaths<T>>(key: Key, value: Get<T, Key>): IfNotExistsOp<T, Key>;
/**
 * Creates an update expression using a type-safe builder pattern.
 *
 * @typeParam T - The entity type the update operates on
 * @param builder - Callback that receives update operations and returns an array of operations
 * @returns An array of update operations ready for compilation
 *
 * @example
 * ```ts
 * const update = exprUpdate<User>(({ set, opAdd }) => [
 *   set("name", "John"),
 *   set("loginCount", opAdd("loginCount", 1))
 * ]);
 * ```
 */
export declare function exprUpdate<T>(builder: (ops: UpdateOps<T>) => AnyOperation<T>[]): UpdateOperation<T>;
/**
 * Compiles an update operation into a DynamoDB-ready expression.
 *
 * @typeParam T - The entity type the update operates on
 * @param operations - The update operations to compile
 * @returns A compiled update with expression string and attribute maps
 */
export declare function compileUpdateExpr<T>(operations: UpdateOperation<T>): CompiledUpdateOperation<T>;
export {};
//# sourceMappingURL=update.d.ts.map