import type { TCorePropositionalExpression, TCorePropositionalVariable, TCorePremise } from "../schemata/propositional.js";
import type { TCoreArgument, TCoreArgumentRoleState } from "../schemata/argument.js";
import type { TCoreChangeset } from "../types/mutation.js";
/**
 * Merges two changesets into one, deduplicating entities by `id` within each
 * bucket (added/modified/removed) with last-write-wins semantics.
 *
 * Use this when a single logical operation requires multiple engine calls that
 * each produce a changeset. For example, creating a conclusion premise requires
 * both `createPremiseWithId` and `setConclusionPremise`, each returning a
 * changeset — `mergeChangesets` combines them into one changeset suitable for
 * a single persistence call.
 *
 * @param a - The first changeset.
 * @param b - The second changeset. Its entries take precedence when both
 *   changesets contain the same entity ID in the same bucket.
 * @returns A merged changeset. Entity categories that are empty after merge
 *   are omitted from the result.
 * @throws {Error} If any entity ID appears in more than one bucket
 *   (added/modified/removed) within the same category after merge. This
 *   indicates a logic error in the caller.
 *
 * @example
 * ```ts
 * const { changes: createChanges } = engine.createPremiseWithId(premiseId, data)
 * const { changes: roleChanges } = engine.setConclusionPremise(premiseId)
 * const combined = mergeChangesets(createChanges, roleChanges)
 * await persistChangeset(db, combined)
 * ```
 */
export declare function mergeChangesets<TExpr extends TCorePropositionalExpression = TCorePropositionalExpression, TVar extends TCorePropositionalVariable = TCorePropositionalVariable, TPremise extends TCorePremise = TCorePremise, TArg extends TCoreArgument = TCoreArgument>(a: TCoreChangeset<TExpr, TVar, TPremise, TArg>, b: TCoreChangeset<TExpr, TVar, TPremise, TArg>): TCoreChangeset<TExpr, TVar, TPremise, TArg>;
/**
 * A single persistence operation extracted from a changeset, tagged with
 * its operation type (`insert`, `update`, or `delete`) and entity kind.
 *
 * Used as the element type for the ordered operation list returned by
 * {@link orderChangeset}.
 */
export type TOrderedOperation<TExpr extends TCorePropositionalExpression = TCorePropositionalExpression, TVar extends TCorePropositionalVariable = TCorePropositionalVariable, TPremise extends TCorePremise = TCorePremise, TArg extends TCoreArgument = TCoreArgument> = {
    type: "delete";
    entity: "expression";
    data: TExpr;
} | {
    type: "delete";
    entity: "variable";
    data: TVar;
} | {
    type: "delete";
    entity: "premise";
    data: TPremise;
} | {
    type: "insert";
    entity: "premise";
    data: TPremise;
} | {
    type: "insert";
    entity: "variable";
    data: TVar;
} | {
    type: "insert";
    entity: "expression";
    data: TExpr;
} | {
    type: "update";
    entity: "expression";
    data: TExpr;
} | {
    type: "update";
    entity: "variable";
    data: TVar;
} | {
    type: "update";
    entity: "premise";
    data: TPremise;
} | {
    type: "update";
    entity: "argument";
    data: TArg;
} | {
    type: "update";
    entity: "roles";
    data: TCoreArgumentRoleState;
};
/**
 * Converts a changeset into a flat, ordered array of persistence operations
 * that is safe to execute sequentially against a relational store with
 * foreign-key constraints.
 *
 * The FK dependency chain is:
 * - `expression.premiseId` → `premise.id`
 * - `expression.variableId` → `variable.id` (for variable-type expressions)
 * - `expression.parentId` → `expression.id` (self-FK for tree structure)
 * - `variable.argumentId` → `argument.id`
 * - `premise.argumentId` → `argument.id`
 *
 * The resulting order guarantees that every referenced row exists before any
 * row that depends on it is inserted, and that every dependent row is removed
 * before the row it references is deleted.
 *
 * Ordering phases:
 * 1. Update premises — ensure premise rows have correct metadata before
 *    dependent deletes run.
 * 2. Reparent expressions — update expressions whose IDs are NOT in the
 *    removed set. This detaches reparented children from doomed parents
 *    before ON DELETE CASCADE runs. Expressions that appear in both
 *    modified and removed are skipped (the row is about to be deleted).
 * 3. Delete expressions — expression rows hold FKs to variables and premises,
 *    so they must be removed first.
 * 4. Delete variables — safe after expression deletes (no remaining FK
 *    references from expressions).
 * 5. Delete premises — safe after all child rows are removed.
 * 6. Insert premises — new premises must exist before their expressions and
 *    variables can be inserted.
 * 7. Insert variables — new variables must exist before variable-type
 *    expressions can reference them.
 * 8. Insert expressions — topologically sorted so parent expressions are
 *    inserted before their children (satisfies the parentId self-FK).
 * 9. Update variables — grouped after inserts for clarity.
 * 10. (No-op — expression updates are now emitted in Phase 2.)
 * 11. Update argument metadata — if present.
 * 12. Update role state — if present.
 *
 * @param changeset - The changeset to convert into ordered operations.
 * @returns A flat array of {@link TOrderedOperation} entries in FK-safe
 *   execution order. Returns an empty array if the changeset is empty.
 */
export declare function orderChangeset<TExpr extends TCorePropositionalExpression = TCorePropositionalExpression, TVar extends TCorePropositionalVariable = TCorePropositionalVariable, TPremise extends TCorePremise = TCorePremise, TArg extends TCoreArgument = TCoreArgument>(changeset: TCoreChangeset<TExpr, TVar, TPremise, TArg>): TOrderedOperation<TExpr, TVar, TPremise, TArg>[];
//# sourceMappingURL=changeset.d.ts.map