import { type TCoreArgumentReference } from "../../schemata/index.js";
import type { TCarryResult, TLinkAnswer, TLinkViolation, TMergedCarriedInput, TResponseLink } from "../../types/response.js";
import type { TArgumentEngineSnapshot } from "../argument-engine.js";
import type { TClaimLookup } from "../interfaces/library.interfaces.js";
import { type TTargetExpander } from "./combined-premise-set.js";
/**
 * What "this expression has this value" says about its columns.
 *
 * - `cube`: exactly the rows where each column in `fixed` has its value and
 *   every other column is free.
 * - `notExpressible`: the rows are not of that shape, so no set of fixed
 *   values says the same thing.
 * - `impossible`: no row gives the expression the value.
 * - `vacuous`: every row does.
 * - `tooLarge`: the expression reads more columns than the search allows.
 */
export type TStatementDecomposition = {
    kind: "cube";
    fixed: Map<string, boolean>;
} | {
    kind: "notExpressible";
} | {
    kind: "impossible";
} | {
    kind: "vacuous";
} | {
    kind: "tooLarge";
};
/**
 * Reads "the target expression `expressionId` has value `value`" as fixed
 * column values, over the expression's own expansion with every column free.
 * Nothing outside the expression enters: not the response's premises, not
 * the response's grounded columns, not the target's axioms.
 */
export declare function decomposeStatement(expander: TTargetExpander, expressionId: string, value: boolean): TStatementDecomposition;
/** What carrying needs from the response, read once per call. */
export interface TCarryInput {
    /** Problems that make the answer `invalid`, decided by the caller. */
    problems: TLinkViolation[];
    /** The argument and version the response answers. */
    into: TCoreArgumentReference;
    /** Every premise of the response, in order. */
    responsePremiseIds: readonly string[];
    links: readonly TResponseLink[];
    linkAnswers: Readonly<Record<string, TLinkAnswer>>;
    target: TArgumentEngineSnapshot;
    /** Resolves the target's claims at the versions it binds. */
    targetClaims: TClaimLookup;
    /**
     * The links whose answers are the reader's own rather than carried into
     * this response from another; they outrank the rest on a conflict.
     */
    ownLinkPremiseIds?: Iterable<string>;
}
/**
 * What a reader's answers on a response's links carry into the argument it
 * answers. Only `agree` answers carry; each agreed link carries exactly what
 * it says, or is reported in `notCarried` with the reason it cannot.
 */
export declare function carryAnswers(input: TCarryInput): TCarryResult;
export declare function mergeCarriedInput(own: {
    variables?: Readonly<Record<string, boolean | null>>;
    operatorAssignments?: Readonly<Record<string, "accepted" | "rejected">>;
    linkAnswers?: Readonly<Record<string, TLinkAnswer>>;
}, carried: Extract<TCarryResult, {
    status: "carried";
}>): TMergedCarriedInput;
//# sourceMappingURL=carry.d.ts.map