lib0 1.0.0-rc.13 → 1.0.0-rc.15

package/dist/delta/transformer/id.d.ts

@@ -0,0 +1,9 @@
+/**
+ * The identity {@link import('./core.js').Template Template}: it maps every change verbatim in both
+ * directions, so both sides stay bit-for-bit equal. A stateless singleton (an attr-rename with no
+ * renames).
+ *
+ * @type {import('./core.js').Template}
+ */
+export const id: import("./core.js").Template;
+//# sourceMappingURL=id.d.ts.map

package/dist/delta/transformer/inline.d.ts

@@ -0,0 +1,90 @@
+/**
+ * Stateful transformer that inlines child nodes whose name is in the configured `names` set. Side A
+ * is the structured representation (inline nodes present, e.g. `<p>some<>text</></p>`), side B is the
+ * inlined representation (inline nodes flattened, e.g. `<p>sometext</p>`).
+ *
+ * The state the user calls "offsets and inline node length" is the segment layout {@link Seg} stored
+ * in `segs`: a coalesced run-length view of the structured side where each inline node is one
+ * structured position expanding to `inlineLen` inlined positions, and every other position (root text
+ * and opaque non-inlined nodes) is a pass-through run. It is kept current incrementally - every mapped
+ * change is folded into `segs` by {@link applySegsChange} rather than re-derived from scratch.
+ *
+ * @extends {Transformer<any,any>}
+ */
+export class InlineTransformer extends Transformer<any, any> {
+    /**
+     * @param {Array<string|null>} names the node names to inline (`null` selects anonymous nodes)
+     */
+    constructor(names: Array<string | null>);
+    /**
+     * @type {Array<string|null>}
+     */
+    names: Array<string | null>;
+    /**
+     * The segment layout of the structured side, maintained incrementally (see {@link applySegsChange}).
+     *
+     * @type {Array<Seg>}
+     */
+    segs: Array<Seg>;
+    /**
+     * Whether the structured side has ever contained a direct inline-node child. Monotonic: once a
+     * change introduces an inline node it stays set (even if that node is later deleted), which only
+     * costs a missed fast-path, never correctness.
+     *
+     * @type {boolean}
+     */
+    hasInline: boolean;
+}
+/**
+ * Template for {@link InlineTransformer}.
+ *
+ * @implements Template
+ */
+export class Inline implements Template {
+    /**
+     * @param {Array<string|null>} names the node names to inline (`null` selects anonymous nodes)
+     */
+    constructor(names: Array<string | null>);
+    names: (string | null)[];
+    get stateless(): boolean;
+    /**
+     * Typed loosely: the inlined output shape is not computed at compile time (it depends on the
+     * runtime `names`), so the B side is `any`.
+     *
+     * @template {delta.DeltaConf} IN
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} _$d
+     * @return {Transformer<IN, any>}
+     */
+    init<IN extends delta.DeltaConf>(_$d: import("../../schema.js").Schema<delta.Delta<IN>>): Transformer<IN, any>;
+}
+export function inline(names: Array<string | null>): Inline;
+/**
+ * Convenience {@link Inline} template that inlines anonymous ("null") child nodes
+ * (`<p>some<>text</></p>` <-> `<p>sometext</p>`) - i.e. `inline([null])`.
+ */
+export const inlineNullNodes: Inline;
+export type Template = import("./core.js").Template;
+import { Transformer } from './core.js';
+/**
+ * @typedef {import('./core.js').Template} Template
+ */
+/**
+ * One entry of the segment layout maintained by {@link InlineTransformer}. A segment is either a
+ * coalesced run of pass-through positions (root text + opaque non-inlined nodes - same length in both
+ * coordinate spaces) or a single inline node (1 structured position that expands to `inlineLen`
+ * inlined positions).
+ */
+declare class Seg {
+    /**
+     * @param {boolean} isInline whether this seg is an inline node (its children are spliced into the parent)
+     * @param {number} structLen
+     * @param {number} inlineLen
+     */
+    constructor(isInline: boolean, structLen: number, inlineLen: number);
+    isInline: boolean;
+    structLen: number;
+    inlineLen: number;
+}
+import * as delta from '../delta.js';
+export {};
+//# sourceMappingURL=inline.d.ts.map

package/dist/delta/transformer/pipe.d.ts

@@ -0,0 +1,271 @@
+/**
+ * @typedef {import('./core.js').Template} Template
+ */
+/**
+ * Marker for absent props in a NormalizedDeltaConf.
+ *
+ * @typedef {{ 'lib0:notset': true }} NotSet
+ */
+/**
+ * DeltaConf in normalized form: all props defined, absent props are set to NotSet.
+ *
+ * ApplyPipe iterates over this form (see ApplyPipeNorm).
+ *
+ * @template Name
+ * @template Attrs
+ * @template Children
+ * @template Text
+ * @template RecursiveChildren
+ * @template RecursiveAttrs
+ * @typedef {{ name: Name, attrs: Attrs, children: Children, text: Text, recursiveChildren: RecursiveChildren, recursiveAttrs: RecursiveAttrs }} NormalizedDeltaConf
+ */
+/**
+ * @template {delta.DeltaConf} C
+ * @typedef {NormalizedDeltaConf<
+ *   C extends { name: infer Name extends string } ? Name : NotSet,
+ *   C extends { attrs: infer Attrs extends {[K:string|number]:any} } ? Attrs : NotSet,
+ *   C extends { children: infer Children } ? Children : NotSet,
+ *   C extends { text: infer Text extends boolean } ? Text : NotSet,
+ *   C extends { recursiveChildren: infer RecursiveChildren extends boolean } ? RecursiveChildren : NotSet,
+ *   C extends { recursiveAttrs: infer RecursiveAttrs extends boolean } ? RecursiveAttrs : NotSet
+ * >} NormalizeDeltaConf
+ */
+/**
+ * Strip NotSet props from a NormalizedDeltaConf, producing a regular DeltaConf again.
+ *
+ * @template NC
+ * @typedef {{ [K in keyof NC as NC[K] extends NotSet ? never : K]: NC[K] } & {}} DenormalizeDeltaConf
+ */
+/**
+ * Intersect a prop of a Filter conf with the corresponding pipe conf prop. The prop is only kept
+ * if it is defined on both sides (mirrors ApplyExpectType).
+ *
+ * @template FilterProp
+ * @template PipeProp
+ * @typedef {FilterProp extends NotSet ? NotSet : PipeProp extends NotSet ? NotSet : FilterProp & PipeProp} FilterConfProp
+ */
+/**
+ * Apply each Template to a NormalizedDeltaConf - must mirror the semantics of ApplyAttrRename /
+ * ApplyExpectType.
+ *
+ * This shape is tuned to stay below typescript's instantiation-depth limit (TS2589) for long
+ * pipes (~85 templates via pipe().init(), measured). What we learned:
+ *
+ * - The per-step destructure of NC is the load-bearing part: typescript resolves types lazily,
+ *   and member inference out of the literal that was passed as a type argument in the previous
+ *   step is what forces resolution of the accumulated conf. Without it (e.g. carrying the conf
+ *   props as individual type params), the attrs accumulate as a deferred PropsRename chain and
+ *   the limit hits at ~45 templates. Local annotations do NOT force resolution: `X & {}`,
+ *   `X extends infer N ? ...`, and an inline `{ attrs: X } extends { attrs: infer A } ? ...`
+ *   roundtrip were all measured to have no effect.
+ * - The recursion must carry a plain object literal. Wrapping the accumulator in a helper alias
+ *   (even a trivial one like NormalizedDeltaConf) defers per step and rebuilds the chain.
+ * - The outer check must be on TS alone. Coupling NC into the check type (e.g.
+ *   `[TS, NC] extends [[...], {...}]`) makes the conditional generic-deferred whenever the conf
+ *   is generic, which sends constraint comparisons (e.g. Pipe<TS> vs Pipe<any>) into infinite
+ *   recursion.
+ * - Each dispatch branch costs instantiation depth. A conf-passthrough template (one whose output
+ *   conf equals its input conf, e.g. transformer/inline, whose init() is typed loosely as
+ *   `Transformer<IN, any>`) needs NO branch: it falls through to the trailing `NC` and composes
+ *   correctly. Adding a branch for it (even `FirstT extends X ? NC : ...`) deepens every step and
+ *   lowers the ~85 ceiling.
+ *
+ * @template {Array<Template>} TS
+ * @template NC
+ * @typedef {TS extends [infer FirstT extends Template, ...infer RestT extends Template[]]
+ *   ? (NC extends { name: infer Name, attrs: infer Attrs extends {[K:string|number]:any}, children: infer Children, text: infer Text, recursiveChildren: infer RecursiveChildren, recursiveAttrs: infer RecursiveAttrs }
+ *     ? ApplyPipeNorm<RestT,
+ *       FirstT extends AttrRename<infer Renames> ? { name: Name, attrs: import('../../ts.js').PropsRename<Attrs extends NotSet ? {} : Attrs, Renames>, children: Children, text: Text, recursiveChildren: RecursiveChildren, recursiveAttrs: RecursiveAttrs } :
+ *       FirstT extends Filter<infer DConf extends delta.DeltaConf> ? (NormalizeDeltaConf<DConf> extends { name: infer FilterName, attrs: infer FilterAttrs, children: infer FilterChildren, text: infer FilterText, recursiveChildren: infer FilterRecursiveChildren, recursiveAttrs: infer FilterRecursiveAttrs } ? {
+ *         name: FilterConfProp<FilterName, Name>,
+ *         attrs: FilterAttrs extends NotSet ? NotSet : Attrs extends NotSet ? NotSet : import('../../ts.js').PropsPickShared<FilterAttrs, Attrs>,
+ *         children: FilterConfProp<FilterChildren, Children>,
+ *         text: FilterConfProp<FilterText, Text>,
+ *         recursiveChildren: FilterConfProp<FilterRecursiveChildren, RecursiveChildren>,
+ *         recursiveAttrs: FilterConfProp<FilterRecursiveAttrs, RecursiveAttrs>
+ *       } : never) :
+ *       NC>
+ *     : NC)
+ *   : NC} ApplyPipeNorm
+ */
+/**
+ * @template {Array<Template>} TS
+ * @template {delta.DeltaConf} IN
+ * @typedef {DenormalizeDeltaConf<ApplyPipeNorm<TS, NormalizeDeltaConf<IN>>>} ApplyPipe
+ */
+/**
+ * Flattens nested Pipe instances into a single flat Template array.
+ * Since pipe() always produces flat Pipes, Inner is already flat and
+ * only one level of unwrapping is needed per Pipe element.
+ * Tail-recursive with an accumulator so the instantiation depth stays constant.
+ *
+ * @template {Array<Template>} TS
+ * @template {Array<Template>} [Acc=[]]
+ * @typedef {TS extends [infer F extends Template, ...infer R extends Template[]]
+ *   ? FlattenTemplates<R, F extends Pipe<infer Inner extends Template[]> ? [...Acc, ...Inner] : [...Acc, F]>
+ *   : Acc} FlattenTemplates
+ */
+/**
+ * Chain multiple Templates together.
+ *
+ * @template {Template[]} TS
+ * @implements Template
+ */
+export class Pipe<TS extends Template[]> implements Template {
+    /**
+     * @param {TS} templates
+     */
+    constructor(templates: TS);
+    /**
+     * @type {TS}
+     */
+    templates: TS;
+    stateless: boolean;
+    /**
+     * @type {PipeTransformer<any,any,this>?}
+     */
+    statelessTransformer: PipeTransformer<any, any, this> | null;
+    /**
+     * @template {delta.DeltaConf} IN
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} _$d
+     * @return {Transformer<IN, ApplyPipe<TS, IN>>}
+     */
+    init<IN extends delta.DeltaConf>(_$d: import("../../schema.js").Schema<delta.Delta<IN>>): Transformer<IN, ApplyPipe<TS, IN>>;
+}
+/**
+ * @template {delta.DeltaConf} A
+ * @template {delta.DeltaConf} B
+ * @template {Pipe<any>} PipeTemplate
+ * @extends {Transformer<A,B>}
+ */
+export class PipeTransformer<A extends delta.DeltaConf, B extends delta.DeltaConf, PipeTemplate extends Pipe<any>> extends Transformer<A, B> {
+    /**
+     * @param {PipeTemplate} tpipe
+     */
+    constructor(tpipe: PipeTemplate);
+    tpipe: PipeTemplate;
+    /**
+     * @type {Transformer<any,any>[]}
+     */
+    ts: Transformer<any, any>[];
+    /**
+     * @param {import('./core.js').TransformResultAny} tin
+     * @return {import('./core.js').TransformResultAny}
+     */
+    apply(tin: import("./core.js").TransformResultAny): import("./core.js").TransformResultAny;
+}
+export function pipe<Ts extends Array<Template>>(...ts: Ts): Pipe<FlattenTemplates<Ts>>;
+export type Template = import("./core.js").Template;
+/**
+ * Marker for absent props in a NormalizedDeltaConf.
+ */
+export type NotSet = {
+    "lib0:notset": true;
+};
+/**
+ * DeltaConf in normalized form: all props defined, absent props are set to NotSet.
+ *
+ * ApplyPipe iterates over this form (see ApplyPipeNorm).
+ */
+export type NormalizedDeltaConf<Name, Attrs, Children, Text, RecursiveChildren, RecursiveAttrs> = {
+    name: Name;
+    attrs: Attrs;
+    children: Children;
+    text: Text;
+    recursiveChildren: RecursiveChildren;
+    recursiveAttrs: RecursiveAttrs;
+};
+export type NormalizeDeltaConf<C extends delta.DeltaConf> = NormalizedDeltaConf<C extends {
+    name: infer Name extends string;
+} ? Name : NotSet, C extends {
+    attrs: infer Attrs extends {
+        [K: string | number]: any;
+    };
+} ? Attrs : NotSet, C extends {
+    children: infer Children;
+} ? Children : NotSet, C extends {
+    text: infer Text extends boolean;
+} ? Text : NotSet, C extends {
+    recursiveChildren: infer RecursiveChildren extends boolean;
+} ? RecursiveChildren : NotSet, C extends {
+    recursiveAttrs: infer RecursiveAttrs extends boolean;
+} ? RecursiveAttrs : NotSet>;
+/**
+ * Strip NotSet props from a NormalizedDeltaConf, producing a regular DeltaConf again.
+ */
+export type DenormalizeDeltaConf<NC> = { [K in keyof NC as NC[K] extends NotSet ? never : K]: NC[K]; } & {};
+/**
+ * Intersect a prop of a Filter conf with the corresponding pipe conf prop. The prop is only kept
+ * if it is defined on both sides (mirrors ApplyExpectType).
+ */
+export type FilterConfProp<FilterProp, PipeProp> = FilterProp extends NotSet ? NotSet : PipeProp extends NotSet ? NotSet : FilterProp & PipeProp;
+/**
+ * Apply each Template to a NormalizedDeltaConf - must mirror the semantics of ApplyAttrRename /
+ * ApplyExpectType.
+ *
+ * This shape is tuned to stay below typescript's instantiation-depth limit (TS2589) for long
+ * pipes (~85 templates via pipe().init(), measured). What we learned:
+ *
+ * - The per-step destructure of NC is the load-bearing part: typescript resolves types lazily,
+ *   and member inference out of the literal that was passed as a type argument in the previous
+ *   step is what forces resolution of the accumulated conf. Without it (e.g. carrying the conf
+ *   props as individual type params), the attrs accumulate as a deferred PropsRename chain and
+ *   the limit hits at ~45 templates. Local annotations do NOT force resolution: `X & {}`,
+ *   `X extends infer N ? ...`, and an inline `{ attrs: X } extends { attrs: infer A } ? ...`
+ *   roundtrip were all measured to have no effect.
+ * - The recursion must carry a plain object literal. Wrapping the accumulator in a helper alias
+ *   (even a trivial one like NormalizedDeltaConf) defers per step and rebuilds the chain.
+ * - The outer check must be on TS alone. Coupling NC into the check type (e.g.
+ *   `[TS, NC] extends [[...], {...}]`) makes the conditional generic-deferred whenever the conf
+ *   is generic, which sends constraint comparisons (e.g. Pipe<TS> vs Pipe<any>) into infinite
+ *   recursion.
+ * - Each dispatch branch costs instantiation depth. A conf-passthrough template (one whose output
+ *   conf equals its input conf, e.g. transformer/inline, whose init() is typed loosely as
+ *   `Transformer<IN, any>`) needs NO branch: it falls through to the trailing `NC` and composes
+ *   correctly. Adding a branch for it (even `FirstT extends X ? NC : ...`) deepens every step and
+ *   lowers the ~85 ceiling.
+ */
+export type ApplyPipeNorm<TS extends Array<Template>, NC> = TS extends [infer FirstT extends Template, ...infer RestT extends Template[]] ? (NC extends {
+    name: infer Name;
+    attrs: infer Attrs extends {
+        [K: string | number]: any;
+    };
+    children: infer Children;
+    text: infer Text;
+    recursiveChildren: infer RecursiveChildren;
+    recursiveAttrs: infer RecursiveAttrs;
+} ? ApplyPipeNorm<RestT, FirstT extends AttrRename<infer Renames> ? {
+    name: Name;
+    attrs: import("../../ts.js").PropsRename<Attrs extends NotSet ? {} : Attrs, Renames>;
+    children: Children;
+    text: Text;
+    recursiveChildren: RecursiveChildren;
+    recursiveAttrs: RecursiveAttrs;
+} : FirstT extends Filter<infer DConf extends delta.DeltaConf> ? (NormalizeDeltaConf<DConf> extends {
+    name: infer FilterName;
+    attrs: infer FilterAttrs;
+    children: infer FilterChildren;
+    text: infer FilterText;
+    recursiveChildren: infer FilterRecursiveChildren;
+    recursiveAttrs: infer FilterRecursiveAttrs;
+} ? {
+    name: FilterConfProp<FilterName, Name>;
+    attrs: FilterAttrs extends NotSet ? NotSet : Attrs extends NotSet ? NotSet : import("../../ts.js").PropsPickShared<FilterAttrs, Attrs>;
+    children: FilterConfProp<FilterChildren, Children>;
+    text: FilterConfProp<FilterText, Text>;
+    recursiveChildren: FilterConfProp<FilterRecursiveChildren, RecursiveChildren>;
+    recursiveAttrs: FilterConfProp<FilterRecursiveAttrs, RecursiveAttrs>;
+} : never) : NC> : NC) : NC;
+export type ApplyPipe<TS extends Array<Template>, IN extends delta.DeltaConf> = DenormalizeDeltaConf<ApplyPipeNorm<TS, NormalizeDeltaConf<IN>>>;
+/**
+ * Flattens nested Pipe instances into a single flat Template array.
+ * Since pipe() always produces flat Pipes, Inner is already flat and
+ * only one level of unwrapping is needed per Pipe element.
+ * Tail-recursive with an accumulator so the instantiation depth stays constant.
+ */
+export type FlattenTemplates<TS extends Array<Template>, Acc extends Array<Template> = []> = TS extends [infer F extends Template, ...infer R extends Template[]] ? FlattenTemplates<R, F extends Pipe<infer Inner extends Template[]> ? [...Acc, ...Inner] : [...Acc, F]> : Acc;
+import * as delta from '../delta.js';
+import { Transformer } from './core.js';
+import { AttrRename } from './rename.js';
+import { Filter } from './filter.js';
+//# sourceMappingURL=pipe.d.ts.map

package/dist/delta/transformer/projection.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Projects an input delta onto a fixed node shape, optionally filling attributes/children from nested
+ * transformers (those whose value is a {@link Transformer} instance) and constants otherwise.
+ *
+ * @template {delta.DeltaConf} A
+ * @template {delta.DeltaConf} B
+ * @extends {Transformer<A,B>}
+ */
+export class ProjectionTransformer<A extends delta.DeltaConf, B extends delta.DeltaConf> extends Transformer<A, B> {
+    /**
+     * @param {string} name
+     * @param {{ [K in string|number]: any }} attrs
+     * @param {Array<Array<any> | string>} children
+     */
+    constructor(name: string, attrs: { [K in string | number]: any; }, children: Array<Array<any> | string>);
+    /**
+     * @type {delta.DeltaBuilderAny|null}
+     */
+    initOut: delta.DeltaBuilderAny | null;
+    ts: {
+        key: number | string;
+        t: Transformer<any, any>;
+    }[];
+    /**
+     * @param {import('./core.js').TransformResultAny} tin
+     * @return {import('./core.js').TransformResultAny}
+     */
+    apply(tin: import("./core.js").TransformResultAny): import("./core.js").TransformResultAny;
+}
+export function projection(name: string, attrs: { [K in string | number]: any; }, children: Array<Array<any> | string>): ProjectionTransformer<delta.DeltaConf, delta.DeltaConf>;
+import * as delta from '../delta.js';
+import { Transformer } from './core.js';
+//# sourceMappingURL=projection.d.ts.map

package/dist/delta/transformer/query.d.ts

@@ -0,0 +1,60 @@
+/**
+ * Projects a single node attribute into a `lib0:value` node's `value` attribute (and back).
+ *
+ * @template {string} AttrName
+ * @implements Template
+ */
+export class QueryAttr<AttrName extends string> implements Template {
+    /**
+     * @param {AttrName} attrName
+     */
+    constructor(attrName: AttrName);
+    attrName: AttrName;
+    get stateless(): boolean;
+    /**
+     * @template {delta.DeltaConf} IN
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} _$d
+     * @return {Transformer<IN, ApplyQueryAttr<AttrName, IN>>}
+     */
+    init<IN extends delta.DeltaConf>(_$d: import("../../schema.js").Schema<delta.Delta<IN>>): Transformer<IN, ApplyQueryAttr<AttrName, IN>>;
+}
+/**
+ * @template {delta.DeltaConf} A
+ * @template {delta.DeltaConf} B
+ * @extends {Transformer<A,B>}
+ */
+export class QueryAttrTransformer<A extends delta.DeltaConf, B extends delta.DeltaConf> extends Transformer<A, B> {
+    /**
+     * @param {string} attrName
+     */
+    constructor(attrName: string);
+    attrName: keyof import("../../ts.js").TypeIsAny<A, {
+        [K: string]: any;
+        [K: number]: any;
+    }, A extends {
+        attrs: infer Attrs;
+    } ? Attrs extends undefined ? {} : Attrs : {}> & (string | number);
+    /**
+     * @param {delta.DeltaBuilder<A>} d
+     * @return {import('./core.js').TransformResultAny}
+     */
+    applyA(d: delta.DeltaBuilder<A>): import("./core.js").TransformResultAny;
+    /**
+     * @param {delta.DeltaBuilder<B>} d
+     * @return {import('./core.js').TransformResultAny}
+     */
+    applyB(d: delta.DeltaBuilder<B>): import("./core.js").TransformResultAny;
+}
+export function query<AttrName extends string>(attrName: AttrName): QueryAttr<AttrName>;
+export type Template = import("./core.js").Template;
+export type ApplyQueryAttr<AttrName extends string, IN extends delta.DeltaConf> = {
+    name: "lib0:value";
+    attrs: {
+        value: IN extends {
+            attrs: { [K in AttrName]: infer V; };
+        } ? V : never;
+    };
+};
+import * as delta from '../delta.js';
+import { Transformer } from './core.js';
+//# sourceMappingURL=query.d.ts.map

package/dist/delta/transformer/rename.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Renames node attributes (`a` -> `b`) in both directions.
+ *
+ * @template {{[K:string|number]:string|number}} Renames
+ * @implements Template
+ * @extends Transformer<any,any>
+ */
+export class AttrRename<Renames extends {
+    [K: string | number]: string | number;
+}> extends Transformer<any, any> implements Template {
+    /**
+     * @param {Renames} renames
+     */
+    constructor(renames: Renames);
+    arenames: Renames;
+    /**
+     * @type {{[K:string|number]:string|number}}
+     */
+    brenames: {
+        [K: string | number]: string | number;
+    };
+    get stateless(): boolean;
+    /**
+     * @template {delta.DeltaConf} IN
+     * @param {import('../../schema.js').Schema<delta.Delta<IN>>} _$d
+     * @return {Transformer<IN,ApplyAttrRename<Renames,IN>>}
+     */
+    init<IN extends delta.DeltaConf>(_$d: import("../../schema.js").Schema<delta.Delta<IN>>): Transformer<IN, ApplyAttrRename<Renames, IN>>;
+    /**
+     * @param {delta.DeltaAny} deltaA
+     * @return {import('./core.js').TransformResultAny}
+     */
+    applyA(deltaA: delta.DeltaAny): import("./core.js").TransformResultAny;
+    /**
+     * @param {delta.DeltaAny} deltaB
+     * @return {import('./core.js').TransformResultAny}
+     */
+    applyB(deltaB: delta.DeltaAny): import("./core.js").TransformResultAny;
+}
+export function rename<Renames extends {
+    [K: string | number]: string | number;
+}>(renames: Renames): AttrRename<Renames>;
+export type Template = import("./core.js").Template;
+export type ApplyAttrRename<Renames extends {
+    [K: string | number]: string | number;
+}, IN extends delta.DeltaConf> = delta.DeltaConfOverwrite<IN, {
+    attrs: import("../../ts.js").PropsRename<delta.DeltaConfGetAttrs<IN>, Renames>;
+}>;
+import { Transformer } from './core.js';
+import * as delta from '../delta.js';
+//# sourceMappingURL=rename.d.ts.map