/**
 * OpValidator — validates raw/canonical op shapes at reducer boundaries.
 *
 * Two responsibilities:
 *
 * 1. **Type recognition** — `RAW_KNOWN_OPS` / `CANONICAL_KNOWN_OPS`
 *    and their `isKnownRaw` / `isKnownCanonical` guards. Used at the
 *    sync/wire boundary to fail-close on unknown op types. // nosemgrep: ts-no-unknown-outside-adapters -- 0025B
 *
 * 2. **Field assertion** — `assertString` / `assertIterable` /
 *    `assertDot` raise `PatchError` with structured context when a
 *    field violates its expected shape. Called from each
 *    `OpStrategy.validate()` method.
 *
 * The class exposes only static methods — there is no instance state to
 * freeze, and the `unknown` inputs on `isKnownRaw` / `isKnownCanonical` // nosemgrep: ts-no-unknown-outside-adapters -- 0025B
 * are intentional parser-boundary types rather than leaked ambiguity.
 *
 * @module domain/services/OpValidator
 */
/** A minimal tagged op shape accepted by the validator entrypoints. */
type TaggedOp = {
    readonly type: string;
};
export default class OpValidator {
    /**
     * Known raw (wire-format) op types. These are the 6 types that
     * appear in persisted patches and on the sync wire.
     */
    static readonly RAW_KNOWN_OPS: ReadonlySet<string>;
    /**
     * Known canonical (internal) op types. Includes the 6 raw types
     * plus the ADR-1 canonical split types `NodePropSet` and `EdgePropSet`.
     */
    static readonly CANONICAL_KNOWN_OPS: ReadonlySet<string>;
    /**
     * Returns true iff the op has a known RAW (wire-format) type.
     * Use this at sync/decode boundaries to reject unknown or // nosemgrep: ts-no-unknown-outside-adapters -- 0025B
     * canonical-only types arriving from the wire.
     */
    static isKnownRaw(op: unknown): boolean;
    /**
     * Returns true iff the op has a known CANONICAL (internal) type.
     * Use this for internal guards after normalization.
     */
    static isKnownCanonical(op: unknown): boolean;
    /** Asserts that `op[field]` is a string. */
    static assertString(op: TaggedOp, field: string): void;
    /**
     * Asserts that `op[field]` is iterable (Array, Set, or anything
     * providing `Symbol.iterator`).
     */
    static assertIterable(op: TaggedOp, field: string): void;
    /**
     * Asserts that `op.dot` is a real `Dot` instance.
     * Reducer entrypoints hydrate raw decoded POJOs before strategy validation.
     */
    static assertDot(op: TaggedOp): void;
}
export {};
