/**
 * @file batched-writes.ts
 * @description Handles batched write operations for entity creation and updates.
 * This module provides functionality to process complex entity mutation operations
 * with proper dependency handling across related entities.
 */
import { EntityMetadata } from '../metadata';
import { BaseContext, GraphQLResolveInfo } from '../types';
/**
 * Type representing an operation process for an entity
 * - 'post' processes run after the operation is complete
 * - 'pre' processes run before the operation
 */
type OperationProcess<G> = {
    type: 'post';
    inject: (value: (G & (object | undefined)) | null) => void;
} | {
    type: 'pre';
    fetch: any;
};
/**
 * Generates operation batches for entity mutations
 *
 * This function analyzes the input entity and its relationships to create a
 * dependency graph of operations that need to be performed. It handles:
 * - Entity creation/updates
 * - Relationship management between entities
 * - Topological sorting of operations to maintain dependency order
 *
 * @param rootInput - The input entity data or array of entities
 * @param rootMeta - Metadata for the entity type
 * @param rootInfo - GraphQL resolve info
 * @param rootContext - Base context
 * @returns A structured object containing tasks, nodes, batches and return order
 */
export declare const generateOperationBatches: <G = unknown, D = unknown>(rootInput: Partial<G> | Partial<G>[], rootMeta: EntityMetadata<G, D>, rootInfo: GraphQLResolveInfo, rootContext: BaseContext) => Promise<{
    tasks: Map<string, {
        meta: EntityMetadata<G, D>;
        operations: Array<{
            nodeId: string;
            type: "create" | "update";
            processing: OperationProcess<G>[];
        }>;
    }>;
    nodes: Map<string, Partial<G>>;
    batches: string[][];
    returnOrder: string[];
}>;
/**
 * Executes the batched write operations in the correct order
 *
 * @param batches - The batches to execute in order
 * @param tasks - Map of tasks to execute
 * @param nodes - Map of nodes to operate on
 * @param returnOrder - The order to return results
 * @returns The result of the operations
 */
export declare const runBatchedWrites: <G = unknown, D = unknown>(batches: Array<string[]>, tasks: Map<string, {
    meta: EntityMetadata<G, D>;
    operations: Array<{
        nodeId: string;
        type: "create" | "update";
        processing: OperationProcess<G>[];
    }>;
}>, nodes: Map<string, Partial<G>>, returnOrder: string[]) => Promise<Partial<G | null>[] | (G & object) | null | undefined>;
export {};