/**
 * Makes the projected (side-B) delta conform to `$schema`, **recursively**: drops attributes, attribute
 * values, child nodes, and text the schema does not recognize, and descends into kept delta-valued
 * attributes and kept child nodes with a nested `conform` (a fresh instance per kept child/attr, kept in
 * step with the content — modelled on `children` + `inline`). A child is kept iff its node-name matches
 * one of the schema's child `$Delta`s; a non-delta child iff it validates against `$children`; text iff
 * the schema allows text. Everything else is dropped, so the output is guaranteed to satisfy `$schema`.
 *
 * Content that needs no per-position handling (text, scalars, and nodes matched by a `$deltaAny`/`$any`
 * schema) is coalesced into pass-through runs, so a `$deltaAny` schema is a true zero-overhead identity
 * and an incremental edit costs O(change), not O(document).
 *
 * `applyA` (A → B) does the full recursive filtering. `applyB` (B → A) is a lightweight reverse: it
 * validates each B-side op against `$schema` — throwing on any op that would break conformance — and
 * otherwise passes the change through to A verbatim (a conformant B-edit is already valid on A). Full
 * drop-aware B→A position remapping is deferred (see {@link ConformTransformer#applyB}).
 * Marks are best-effort — marks on kept children/attrs ride through the position map; marks anchored to
 * dropped content are dropped.
 *
 * @template {delta.DeltaConf} SchemaConf
 * @template {delta.DeltaConf} [IN=any]
 * @extends {Template<IN, SchemaConf>}
 */
export class Conform<SchemaConf extends delta.DeltaConf, IN extends delta.DeltaConf = any> extends Template<IN, SchemaConf> {
    /**
     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} $d input delta schema
     * @param {import('../../schema.js').Schema<delta.Delta<SchemaConf>>} $schema the schema the output must match
     */
    constructor($d: import("../../schema.js").Schema<delta.Delta<IN>>, $schema: import("../../schema.js").Schema<delta.Delta<SchemaConf>>);
    $schema: s.Schema<delta.Delta<SchemaConf>>;
    config: Config;
}
/**
 * Stateful, recursive transformer produced by {@link Conform}. See {@link Conform} for semantics.
 *
 * The A→B layout lives in {@link ConformTransformer#cmap} (the *child* map), a delta reused as a
 * coalesced positional map (like `children`'s `childTs`): a `retain(n)` run = pass-through positions, an
 * `insert([t])` = a child routed through nested conform `t`, a `delete(n)` run = dropped positions
 * (width 0 on B). It is rebuilt only on a structural change, carrying the nested transformers by
 * reference so their state survives; a change with only retains/modifies is routed in place.
 *
 * @extends {Transformer<any,any>}
 */
export class ConformTransformer extends Transformer<any, any> {
    /**
     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $in
     * @param {import('../../schema.js').Schema<delta.Delta<any>>} $out
     * @param {Config} config the schema-derived read-only config (computed once, see {@link configOf})
     */
    constructor($in: import("../../schema.js").Schema<delta.Delta<any>>, $out: import("../../schema.js").Schema<delta.Delta<any>>, config: Config);
    config: Config;
    /** @type {delta.DeltaBuilderAny} the coalesced child layout map */
    cmap: delta.DeltaBuilderAny;
    /** @type {Map<string|number, ConformTransformer>} nested conforms for delta-valued attributes */
    transformAttrs: Map<string | number, ConformTransformer>;
}
export function conform<IN extends delta.DeltaConf, SchemaConf extends delta.DeltaConf>($d: import("../../schema.js").Schema<delta.Delta<IN>>, $schema: import("../../schema.js").Schema<delta.Delta<SchemaConf>>): Conform<SchemaConf, IN>;
/**
 * The expanded matcher for a children / attr-value schema.
 */
export type Allowed = {
    byName: Map<string, delta.$Delta<any>>;
    wild: delta.$Delta<any> | null;
    passAny: boolean;
    $scalar: import("../../schema.js").Schema<any>;
};
/**
 * The read-only, schema-derived configuration of a conform transformer. Computed once per schema (see
 * {@link configOf}) and shared by every transformer instance built from that schema — many instances are
 * created for the children of one schema, so this avoids re-expanding the schema each time.
 */
export type Config = {
    passthrough: boolean;
    hasText: boolean;
    childAllowed: Allowed;
    attrsLoose: boolean;
    attrAllowed: Map<string | number, Allowed>;
};
import * as delta from '../delta.js';
import { Template } from './core.js';
import * as s from '../../schema.js';
import { Transformer } from './core.js';
//# sourceMappingURL=conform.d.ts.map