/**
 * ConflictAnalysisRequest — validated request object for conflict analysis.
 *
 * Owns the boundary parsing and normalization for analysis options so the
 * analyzer service can orchestrate instead of shape-checking raw bags.
 *
 * @module domain/services/strand/ConflictAnalysisRequest
 */
export type ConflictTargetSelector = {
    targetKind: 'node' | 'edge' | 'node_property' | 'edge_property';
    entityId?: string;
    propertyKey?: string;
    from?: string;
    to?: string;
    label?: string;
};
/**
 * The subset of a ConflictTargetSelector that survives snapshot
 * hashing. Used by toSnapshotFilterRecord — explicit named type so
 * the filter shape has an authoritative home.
 */
export type ConflictAnalysisFilterTarget = Readonly<{
    readonly targetKind: ConflictTargetSelector['targetKind'];
    readonly entityId?: string;
    readonly propertyKey?: string;
    readonly from?: string;
    readonly to?: string;
    readonly label?: string;
}>;
/**
 * Runtime-backed snapshot carrier of the request's active filters.
 * Each field is optional or nullable; consumers feed the whole
 * record into the analyzer's canonical-JSON hasher.
 */
export type ConflictAnalysisFilterRecord = Readonly<{
    readonly entityId: string | null;
    readonly target: ConflictAnalysisFilterTarget | null;
    readonly kind: readonly string[] | null;
    readonly writerId: string | null;
}>;
/** Raw user-supplied analysis options accepted at the public API boundary. */
export type ConflictAnalyzeOptions = {
    at?: {
        lamportCeiling?: number | null;
    };
    strandId?: string;
    entityId?: string;
    target?: ConflictTargetSelector | null;
    kind?: string | string[];
    writerId?: string;
    evidence?: 'summary' | 'standard' | 'full';
    scanBudget?: {
        maxPatches?: number;
    };
};
type EvidenceLevel = 'summary' | 'standard' | 'full';
type TraceFilter = {
    kind: string;
    target: {
        touchesEntity(entityId: string): boolean;
        matchesSelector(selector: ConflictTargetSelector): boolean;
    };
    touchesWriter(writerId: string): boolean;
};
/**
 * Runtime-backed normalized request for analyzer execution.
 */
export default class ConflictAnalysisRequest {
    readonly lamportCeiling: number | null;
    readonly strandId: string | null;
    readonly entityId: string | null;
    readonly target: Readonly<ConflictTargetSelector> | null;
    readonly kinds: readonly string[] | null;
    readonly writerId: string | null;
    readonly evidence: EvidenceLevel;
    readonly maxPatches: number | null;
    constructor({ lamportCeiling, strandId, entityId, target, kinds, writerId, evidence, maxPatches, }: {
        lamportCeiling: number | null;
        strandId: string | null;
        entityId: string | null;
        target: ConflictTargetSelector | null;
        kinds: string[] | null;
        writerId: string | null;
        evidence: EvidenceLevel;
        maxPatches: number | null;
    });
    /**
     * Parses raw user input into a validated request object.
     */
    static from(options: ConflictAnalyzeOptions | null | undefined): ConflictAnalysisRequest;
    /**
     * Reports whether the request resolves through a strand coordinate.
     */
    usesStrandCoordinate(): boolean;
    /**
     * Tests whether a conflict trace passes all filters in this request.
     */
    matchesTrace(trace: TraceFilter): boolean;
    private _passesKindFilter;
    private _passesEntityFilter;
    private _passesTargetFilter;
    private _passesWriterFilter;
    /**
     * Returns a structural record of the active filters for snapshot hashing.
     */
    toSnapshotFilterRecord(): ConflictAnalysisFilterRecord;
    private static _normalizeOptionalString;
    private static _normalizeLamportCeiling;
    private static _normalizeTarget;
    private static _validateTarget;
    private static _requireTargetFields;
    private static _normalizeKinds;
    private static _normalizeEvidence;
    private static _normalizeMaxPatches;
    private static _snapshotTarget;
    private static _isValidLamportCeiling;
    private static _validateKinds;
    private static _kindToContext;
}
export {};
