lib0 0.2.115-1 → 0.2.115-3

package/delta/d2.d.ts

@@ -20,8 +20,9 @@ export const $attribution: s.Schema<Attribution>;
  */
 /**
  * @typedef {{
- *   name?: string
- *   attrs?: { [Key in string|number|symbol]: DeltaAttrOpJSON },
+ *   type: 'delta',
+ *   name?: string,
+ *   attrs?: { [Key in string|number]: DeltaAttrOpJSON },
  *   children?: Array<DeltaListOpJSON>
  * }} DeltaJSON
  */
@@ -31,10 +32,22 @@ export const $attribution: s.Schema<Attribution>;
 /**
  * @typedef {{ type: 'insert', value: any, prevValue?: any, attribution?: Attribution } | { type: 'delete', prevValue?: any, attribution?: Attribution } | { type: 'modify', value: DeltaJSON }} DeltaAttrOpJSON
  */
+/**
+ * @typedef {TextOp|InsertOp<any>|DeleteOp|RetainOp|ModifyOp<any>} ChildrenOpAny
+ */
+/**
+ * @typedef {AttrInsertOp<any>|AttrDeleteOp<any>|AttrModifyOp} AttrOpAny
+ */
+/**
+ * @typedef {ChildrenOpAny|AttrOpAny} _OpAny
+ */
 /**
  * @type {s.Schema<DeltaAttrOpJSON>}
  */
 export const $deltaMapChangeJson: s.Schema<DeltaAttrOpJSON>;
+/**
+ * @typedef {unknown & DeltaAny} Q
+ */
 export class TextOp extends list.ListNode {
     /**
      * @param {string} insert
@@ -42,21 +55,38 @@ export class TextOp extends list.ListNode {
      * @param {Attribution?} attribution
      */
     constructor(insert: string, format: FormattingAttributes | null, attribution: Attribution | null);
-    insert: string;
-    format: FormattingAttributes | null;
+    /**
+     * @readonly
+     * @type {string}
+     */
+    readonly insert: string;
+    /**
+     * @readonly
+     * @type {FormattingAttributes|null}
+     */
+    readonly format: FormattingAttributes | null;
     attribution: Attribution | null;
+    /**
+     * @type {string?}
+     */
+    _fingerprint: string | null;
+    /**
+     * @param {string} newVal
+     */
+    _updateInsert(newVal: string): void;
     /**
      * @return {'insert'}
      */
     get type(): "insert";
     get length(): number;
+    get fingerprint(): string;
     /**
      * Remove a part of the operation (similar to Array.splice)
      *
      * @param {number} offset
      * @param {number} len
      */
-    _splice(offset: number, len: number): void;
+    _splice(offset: number, len: number): this;
     /**
      * @return {DeltaListOpJSON}
      */
@@ -64,37 +94,63 @@ export class TextOp extends list.ListNode {
     /**
      * @return {TextOp}
      */
-    clone(): TextOp;
+    clone(start?: number, end?: number): TextOp;
     /**
      * @param {TextOp} other
      */
     [traits.EqualityTraitSymbol](other: TextOp): boolean;
 }
 /**
- * @template ArrayContent
+ * @template {encoding.AnyEncodable|DeltaAny} ArrayContent
  */
-export class InsertOp<ArrayContent> extends list.ListNode {
+export class InsertOp<ArrayContent extends encoding.AnyEncodable | DeltaAny> extends list.ListNode {
     /**
      * @param {Array<ArrayContent>} insert
      * @param {FormattingAttributes|null} format
      * @param {Attribution?} attribution
      */
     constructor(insert: Array<ArrayContent>, format: FormattingAttributes | null, attribution: Attribution | null);
-    insert: ArrayContent[];
-    format: FormattingAttributes | null;
-    attribution: Attribution | null;
+    /**
+     * @readonly
+     * @type {Array<ArrayContent>}
+     */
+    readonly insert: Array<ArrayContent>;
+    /**
+     * @readonly
+     * @type {FormattingAttributes?}
+     */
+    readonly format: FormattingAttributes | null;
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
+    readonly attribution: Attribution | null;
+    /**
+     * @type {string?}
+     */
+    _fingerprint: string | null;
+    /**
+     * @param {ArrayContent} newVal
+     */
+    _updateInsert(newVal: ArrayContent): void;
     /**
      * @return {'insert'}
      */
     get type(): "insert";
     get length(): number;
+    /**
+     * @param {number} i
+     * @return {Extract<ArrayContent,DeltaAny>}
+     */
+    _modValue(i: number): Extract<ArrayContent, DeltaAny>;
+    get fingerprint(): string;
     /**
      * Remove a part of the operation (similar to Array.splice)
      *
      * @param {number} offset
      * @param {number} len
      */
-    _splice(offset: number, len: number): void;
+    _splice(offset: number, len: number): this;
     /**
      * @return {DeltaListOpJSON}
      */
@@ -102,35 +158,48 @@ export class InsertOp<ArrayContent> extends list.ListNode {
     /**
      * @return {InsertOp<ArrayContent>}
      */
-    clone(): InsertOp<ArrayContent>;
+    clone(start?: number, end?: number): InsertOp<ArrayContent>;
     /**
      * @param {InsertOp<ArrayContent>} other
      */
     [traits.EqualityTraitSymbol](other: InsertOp<ArrayContent>): boolean;
 }
-export class DeleteOp extends list.ListNode {
+/**
+ * @template {encoding.AnyEncodable|DeltaAny} [Children=never]
+ * @template {string} [Text=never]
+ */
+export class DeleteOp<Children extends encoding.AnyEncodable | DeltaAny = never, Text extends string = never> extends list.ListNode {
     /**
      * @param {number} len
      */
     constructor(len: number);
     delete: number;
+    /**
+     * @type {(Children|Text) extends never ? null : (Delta<any,{},Children,Text>?)}
+     */
+    prevValue: (Children | Text) extends never ? null : (Delta<any, {}, Children, Text> | null);
+    /**
+     * @type {string|null}
+     */
+    _fingerprint: string | null;
     /**
      * @return {'delete'}
      */
     get type(): "delete";
     get length(): number;
+    get fingerprint(): string;
     /**
      * Remove a part of the operation (similar to Array.splice)
      *
      * @param {number} _offset
      * @param {number} len
      */
-    _splice(_offset: number, len: number): void;
+    _splice(_offset: number, len: number): this;
     /**
      * @return {DeltaListOpJSON}
      */
     toJSON(): DeltaListOpJSON;
-    clone(): DeleteOp;
+    clone(start?: number, end?: number): DeleteOp<never, never>;
     /**
      * @param {DeleteOp} other
      */
@@ -143,26 +212,43 @@ export class RetainOp extends list.ListNode {
      * @param {Attribution?} attribution
      */
     constructor(retain: number, format: FormattingAttributes | null, attribution: Attribution | null);
-    retain: number;
-    format: FormattingAttributes | null;
-    attribution: Attribution | null;
+    /**
+     * @readonly
+     * @type {number}
+     */
+    readonly retain: number;
+    /**
+     * @readonly
+     * @type {FormattingAttributes?}
+     */
+    readonly format: FormattingAttributes | null;
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
+    readonly attribution: Attribution | null;
+    /**
+     * @type {string|null}
+     */
+    _fingerprint: string | null;
     /**
      * @return {'retain'}
      */
     get type(): "retain";
     get length(): number;
+    get fingerprint(): string;
     /**
      * Remove a part of the operation (similar to Array.splice)
      *
      * @param {number} _offset
      * @param {number} len
      */
-    _splice(_offset: number, len: number): void;
+    _splice(_offset: number, len: number): this;
     /**
      * @return {DeltaListOpJSON}
      */
     toJSON(): DeltaListOpJSON;
-    clone(): RetainOp;
+    clone(start?: number, end?: number): RetainOp;
     /**
      * @param {RetainOp} other
      */
@@ -171,30 +257,51 @@ export class RetainOp extends list.ListNode {
 /**
  * Delta that can be applied on a YType Embed
  *
- * @template {Delta<any,any,any,any,any>} DTypes
+ * @template {DeltaAny} [DTypes=DeltaAny]
  */
-export class ModifyOp<DTypes extends Delta<any, any, any, any, any>> extends list.ListNode {
+export class ModifyOp<DTypes extends DeltaAny = DeltaAny> extends list.ListNode {
     /**
      * @param {DTypes} delta
      * @param {FormattingAttributes|null} format
      * @param {Attribution?} attribution
      */
     constructor(delta: DTypes, format: FormattingAttributes | null, attribution: Attribution | null);
-    value: DTypes;
-    format: FormattingAttributes | null;
-    attribution: Attribution | null;
+    /**
+     * @readonly
+     * @type {DTypes}
+     */
+    readonly value: DTypes;
+    /**
+     * @readonly
+     * @type {FormattingAttributes?}
+     */
+    readonly format: FormattingAttributes | null;
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
+    readonly attribution: Attribution | null;
+    /**
+     * @type {string|null}
+     */
+    _fingerprint: string | null;
     /**
      * @return {'modify'}
      */
     get type(): "modify";
     get length(): number;
+    /**
+     * @type {DeltaBuilderAny}
+     */
+    get _modValue(): DeltaBuilderAny;
+    get fingerprint(): string;
     /**
      * Remove a part of the operation (similar to Array.splice)
      *
      * @param {number} _offset
      * @param {number} _len
      */
-    _splice(_offset: number, _len: number): void;
+    _splice(_offset: number, _len: number): this;
     /**
      * @return {DeltaListOpJSON}
      */
@@ -209,10 +316,10 @@ export class ModifyOp<DTypes extends Delta<any, any, any, any, any>> extends lis
     [traits.EqualityTraitSymbol](other: ModifyOp<any>): boolean;
 }
 /**
- * @template V
- * @template {string|number|symbol} [K=any]
+ * @template {encoding.AnyEncodable|DeltaAny} V
+ * @template {string|number} [K=any]
  */
-export class MapInsertOp<V, K extends string | number | symbol = any> {
+export class AttrInsertOp<V extends encoding.AnyEncodable | DeltaAny, K extends string | number = any> {
     /**
      * @param {K} key
      * @param {V} value
@@ -221,22 +328,38 @@ export class MapInsertOp<V, K extends string | number | symbol = any> {
      */
     constructor(key: K, value: V, prevValue: V | undefined, attribution: Attribution | null);
     /**
+     * @readonly
      * @type {K}
      */
-    key: K;
+    readonly key: K;
     /**
+     * @readonly
      * @type {V}
      */
-    value: V;
+    readonly value: V;
     /**
+     * @readonly
      * @type {V|undefined}
      */
-    prevValue: V | undefined;
-    attribution: Attribution | null;
+    readonly prevValue: V | undefined;
+    /**
+     * @readonly
+     * @type {Attribution?}
+     */
+    readonly attribution: Attribution | null;
+    /**
+     * @type {string|null}
+     */
+    _fingerprint: string | null;
     /**
      * @return {'insert'}
      */
     get type(): "insert";
+    /**
+     * @type {DeltaBuilderAny}
+     */
+    get _modValue(): DeltaBuilderAny;
+    get fingerprint(): string;
     toJSON(): {
         type: "insert";
         value: V | DeltaJSON;
@@ -245,24 +368,24 @@ export class MapInsertOp<V, K extends string | number | symbol = any> {
     } | {
         attribution?: undefined;
     }) & ({
-        prevValue: V & ({} | null);
+        prevValue: V & {};
     } | {
         prevValue?: undefined;
     }));
     /**
-     * @return {MapInsertOp<V,K>}
+     * @return {AttrInsertOp<V,K>}
      */
-    clone(): MapInsertOp<V, K>;
+    clone(): AttrInsertOp<V, K>;
     /**
-     * @param {MapInsertOp<V>} other
+     * @param {AttrInsertOp<V>} other
      */
-    [traits.EqualityTraitSymbol](other: MapInsertOp<V>): boolean;
+    [traits.EqualityTraitSymbol](other: AttrInsertOp<V>): boolean;
 }
 /**
  * @template V
- * @template [K=string]
+ * @template {string|number} [K=string]
  */
-export class MapDeleteOp<V, K = string> {
+export class AttrDeleteOp<V, K extends string | number = string> {
     /**
      * @param {K} key
      * @param {V|undefined} prevValue
@@ -278,65 +401,81 @@ export class MapDeleteOp<V, K = string> {
      */
     prevValue: V | undefined;
     attribution: Attribution | null;
+    /**
+     * @type {string|null}
+     */
+    _fingerprint: string | null;
     get value(): undefined;
     /**
      * @type {'delete'}
      */
     get type(): "delete";
+    get fingerprint(): string;
     /**
      * @return {DeltaAttrOpJSON}
      */
     toJSON(): DeltaAttrOpJSON;
-    clone(): MapDeleteOp<V, K>;
+    clone(): AttrDeleteOp<V, K>;
     /**
-     * @param {MapDeleteOp<V>} other
+     * @param {AttrDeleteOp<V>} other
      */
-    [traits.EqualityTraitSymbol](other: MapDeleteOp<V>): boolean;
+    [traits.EqualityTraitSymbol](other: AttrDeleteOp<V>): boolean;
 }
 /**
- * @template {DeltaAny} Modifier
- * @template [K=string]
+ * @template {DeltaAny} [Modifier=DeltaAny]
+ * @template {string|number} [K=string]
  */
-export class MapModifyOp<Modifier extends DeltaAny, K = string> {
+export class AttrModifyOp<Modifier extends DeltaAny = DeltaAny, K extends string | number = string> {
     /**
      * @param {K} key
      * @param {Modifier} delta
      */
     constructor(key: K, delta: Modifier);
     /**
+     * @readonly
      * @type {K}
      */
-    key: K;
+    readonly key: K;
     /**
+     * @readonly
      * @type {Modifier}
      */
-    value: Modifier;
+    readonly value: Modifier;
+    /**
+     * @type {string|null}
+     */
+    _fingerprint: string | null;
     /**
      * @type {'modify'}
      */
     get type(): "modify";
+    get fingerprint(): string;
+    /**
+     * @return {DeltaBuilder}
+     */
+    get _modValue(): DeltaBuilder;
     /**
      * @return {DeltaAttrOpJSON}
      */
     toJSON(): DeltaAttrOpJSON;
     /**
-     * @return {MapModifyOp<Modifier,K>}
+     * @return {AttrModifyOp<Modifier,K>}
      */
-    clone(): MapModifyOp<Modifier, K>;
+    clone(): AttrModifyOp<Modifier, K>;
     /**
-     * @param {MapModifyOp<Modifier>} other
+     * @param {AttrModifyOp<Modifier>} other
      */
-    [traits.EqualityTraitSymbol](other: MapModifyOp<Modifier>): boolean;
+    [traits.EqualityTraitSymbol](other: AttrModifyOp<Modifier>): boolean;
 }
 /**
- * @type {s.Schema<MapDeleteOp<any> | DeleteOp>}
+ * @type {s.Schema<AttrDeleteOp<any> | DeleteOp>}
  */
-export const $deleteOp: s.Schema<MapDeleteOp<any> | DeleteOp>;
+export const $deleteOp: s.Schema<AttrDeleteOp<any> | DeleteOp>;
 /**
- * @type {s.Schema<MapInsertOp<any> | InsertOp<any>>}
+ * @type {s.Schema<AttrInsertOp<any> | InsertOp<any>>}
  */
-export const $insertOp: s.Schema<MapInsertOp<any> | InsertOp<any>>;
-export function $insertOpWith<Content>($content: s.Schema<Content>): s.Schema<MapInsertOp<Content> | InsertOp<Content>>;
+export const $insertOp: s.Schema<AttrInsertOp<any> | InsertOp<any>>;
+export function $insertOpWith<Content extends encoding.AnyEncodable | DeltaAny>($content: s.Schema<Content>): s.Schema<AttrInsertOp<Content> | InsertOp<Content>>;
 /**
  * @type {s.Schema<TextOp>}
  */
@@ -346,24 +485,53 @@ export const $textOp: s.Schema<TextOp>;
  */
 export const $retainOp: s.Schema<RetainOp>;
 /**
- * @type {s.Schema<MapModifyOp<any> | ModifyOp<any>>}
+ * @type {s.Schema<AttrModifyOp | ModifyOp>}
+ */
+export const $modifyOp: s.Schema<AttrModifyOp | ModifyOp>;
+export function $modifyOpWith<Modify extends DeltaAny>($content: s.Schema<Modify>): s.Schema<AttrModifyOp<Modify> | ModifyOp<Modify>>;
+export const $anyOp: s.Schema<AttrInsertOp<any, any> | InsertOp<any> | AttrDeleteOp<any, string> | DeleteOp<never, never> | TextOp | AttrModifyOp<DeltaAny, string> | ModifyOp<DeltaAny>>;
+/**
+ * @template {Array<any>|string} C1
+ * @template {Array<any>|string} C2
+ * @typedef {Extract<C1 | C2, Array<any>> extends never
+ *   ? never
+ *   : (Array<(Extract<C1 | C2,Array<any>> extends Array<infer AC1> ? (unknown extends AC1 ? never : AC1) : never)>)} MergeListArrays
+ */
+/**
+ * @template {{[Key in string|number]: any}} Attrs
+ * @template {string|number} Key
+ * @template {any} Val
+ * @typedef {{ [K in (Key | keyof Attrs)]: (unknown extends Attrs[K] ? never : Attrs[K]) | (Key extends K ? Val : never) }} AddToAttrs
+ */
+/**
+ * @template {{[Key in string|number|symbol]: any}} Attrs
+ * @template {{[Key in string|number|symbol]: any}} NewAttrs
+ * @typedef {{ [K in (keyof NewAttrs | keyof Attrs)]: (unknown extends Attrs[K] ? never : Attrs[K]) | (unknown extends NewAttrs[K] ? never : NewAttrs[K]) }} MergeAttrs
+ */
+/**
+ * @template X
+ * @typedef {0 extends (1 & X) ? null : X} _AnyToNull
+ */
+/**
+ * @template {s.Schema<Delta<any,any,any,any,any>>|null} Schema
+ * @typedef {_AnyToNull<Schema> extends null ? Delta<any,{[key:string|number]:any},any,string> : (Schema extends s.Schema<infer D> ? D : never)} AllowedDeltaFromSchema
+ */
+/**
+ * @typedef {Delta<any,{ [k:string|number]: any },any,any,any>} DeltaAny
+ */
+/**
+ * @typedef {DeltaBuilder<any,{ [k:string|number]: any },any,any,any>} DeltaBuilderAny
  */
-export const $modifyOp: s.Schema<MapModifyOp<any> | ModifyOp<any>>;
-export function $modifyOpWith<Modify extends DeltaAny>($content: s.Schema<Modify>): s.Schema<MapModifyOp<Modify> | ModifyOp<Modify>>;
-export const $anyOp: s.Schema<MapInsertOp<any, any> | InsertOp<any> | MapDeleteOp<any, string> | DeleteOp | TextOp | MapModifyOp<any, string> | ModifyOp<any>>;
-export function forEachAttr<Attrs_1 extends {
-    [key: string | number | symbol]: any;
-} = {}>(d: Delta<any, Attrs_1, any, any, any>, handler: (v: { [K in keyof Attrs_1]: MapInsertOp<Attrs_1[K], K> | MapDeleteOp<Attrs_1[K], K> | (Delta extends Attrs_1[K] ? MapModifyOp<Extract<Attrs_1[K], Delta>, K> : never); }[keyof Attrs_1]) => any): void;
 /**
  * @template {string} [NodeName=any]
- * @template {{[key:string|number|symbol]:any}} [Attrs={}]
- * @template {any} [Children=never]
+ * @template {{[k:string|number]:any}} [Attrs={}]
+ * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
  * @template {string|never} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  */
 export class Delta<NodeName extends string = any, Attrs extends {
-    [key: string | number | symbol]: any;
-} = {}, Children extends unknown = never, Text extends string | never = never, Schema extends s.Schema<Delta<any, any, any, any, any>> | null = any> {
+    [k: string | number]: any;
+} = {}, Children extends encoding.AnyEncodable | DeltaAny | never = never, Text extends string | never = never, Schema extends s.Schema<Delta<any, any, any, any, any>> | null = any> {
     /**
      * @param {NodeName} [name]
      * @param {Schema} [$schema]
@@ -372,10 +540,12 @@ export class Delta<NodeName extends string = any, Attrs extends {
     name: NodeName | null;
     $schema: NonNullable<Schema> | null;
     /**
-     * @type {{ [K in keyof Attrs]?: MapInsertOp<Attrs[K],K>|MapDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? MapModifyOp<Extract<Attrs[K],Delta>,K> : never) } & { [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: MapInsertOp<Attrs[K],K>|MapDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? MapModifyOp<Extract<Attrs[K],Delta>,K> : never) }[keyof Attrs]> }}
+     * @type {{ [K in keyof Attrs]?: K extends string|number ? (AttrInsertOp<Attrs[K],K>|AttrDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? AttrModifyOp<Extract<Attrs[K],DeltaAny>,K> : never)) : never }
+     *   & { [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: K extends string|number ? (AttrInsertOp<Attrs[K],K>|AttrDeleteOp<Attrs[K],K>|(Delta extends Attrs[K] ? AttrModifyOp<Extract<Attrs[K],DeltaAny>,K> : never)) : never }[keyof Attrs]> }
+     * }
      */
-    attrs: { [K in keyof Attrs]?: MapInsertOp<Attrs[K], K> | MapDeleteOp<Attrs[K], K> | (Delta extends Attrs[K] ? MapModifyOp<Extract<Attrs[K], Delta>, K> : never); } & {
-        [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: MapInsertOp<Attrs[K], K> | MapDeleteOp<Attrs[K], K> | (Delta extends Attrs[K] ? MapModifyOp<Extract<Attrs[K], Delta>, K> : never); }[keyof Attrs]>;
+    attrs: { [K in keyof Attrs]?: K extends string | number ? (AttrInsertOp<Attrs[K], K> | AttrDeleteOp<Attrs[K], K> | (Delta extends Attrs[K] ? AttrModifyOp<Extract<Attrs[K], DeltaAny>, K> : never)) : never; } & {
+        [Symbol.iterator]: () => Iterator<{ [K in keyof Attrs]: K extends string | number ? (AttrInsertOp<Attrs[K], K> | AttrDeleteOp<Attrs[K], K> | (Delta extends Attrs[K] ? AttrModifyOp<Extract<Attrs[K], DeltaAny>, K> : never)) : never; }[keyof Attrs]>;
     };
     /**
      * @type {list.List<
@@ -387,10 +557,20 @@ export class Delta<NodeName extends string = any, Attrs extends {
      * >}
      */
     children: list.List<RetainOp | DeleteOp | (Text extends never ? never : TextOp) | (Children extends never ? never : InsertOp<Children>) | (Delta extends Children ? ModifyOp<Extract<Children, Delta<any, any, any, any, any>>> : never)>;
+    childCnt: number;
     /**
      * @type {any}
      */
     origin: any;
+    /**
+     * @type {string|null}
+     */
+    _fingerprint: string | null;
+    isDone: boolean;
+    /**
+     * @type {string}
+     */
+    get fingerprint(): string;
     isEmpty(): boolean;
     /**
      * @return {DeltaJSON}
@@ -402,26 +582,37 @@ export class Delta<NodeName extends string = any, Attrs extends {
      */
     equals(other: Delta<any, any, any, any, any>): boolean;
     /**
-     * @return {this}
+     * @param {number} start
+     * @param {number} end
+     * @return {Delta<NodeName,Attrs,Children,Text,Schema>}
+     */
+    slice(start?: number, end?: number): Delta<NodeName, Attrs, Children, Text, Schema>;
+    /**
+     * Mark this delta as done and perform some cleanup (e.g. remove appended retains without
+     * formats&attributions). In the future, there might be additional merge operations that can be
+     * performed to result in smaller deltas. Set `markAsDone=false` to only perform the cleanup.
+     *
+     * @return {Delta<NodeName,Attrs,Children,Text,Schema>}
      */
-    clone(): this;
+    done(markAsDone?: boolean): Delta<NodeName, Attrs, Children, Text, Schema>;
     /**
      * @param {any} other
      * @return {boolean}
      */
     [traits.EqualityTraitSymbol](other: any): boolean;
 }
+export function clone<D extends DeltaAny>(d: D): D extends Delta<infer NodeName_1, infer Attrs_1, infer Children_1, infer Text, infer Schema_1> ? DeltaBuilder<NodeName_1, Attrs_1, Children_1, Text, Schema_1> : never;
 /**
  * @template {string} [NodeName=any]
- * @template {{[key:string|number|symbol]:any}} [Attrs={}]
- * @template {any} [Children=never]
+ * @template {{[key:string|number]:any}} [Attrs={}]
+ * @template {encoding.AnyEncodable|DeltaAny|never} [Children=never]
  * @template {string|never} [Text=never]
  * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
  * @extends {Delta<NodeName,Attrs,Children,Text,Schema>}
  */
 export class DeltaBuilder<NodeName extends string = any, Attrs extends {
-    [key: string | number | symbol]: any;
-} = {}, Children extends unknown = never, Text extends string | never = never, Schema extends s.Schema<Delta<any, any, any, any, any>> | null = any> extends Delta<NodeName, Attrs, Children, Text, Schema> {
+    [key: string | number]: any;
+} = {}, Children extends encoding.AnyEncodable | DeltaAny | never = never, Text extends string | never = never, Schema extends s.Schema<Delta<any, any, any, any, any>> | null = any> extends Delta<NodeName, Attrs, Children, Text, Schema> {
     /**
      * @type {FormattingAttributes?}
      */
@@ -459,11 +650,11 @@ export class DeltaBuilder<NodeName extends string = any, Attrs extends {
      *   NodeName,
      *   Attrs,
      *   Exclude<NewContent,string>[number]|Children,
-     *   (Extract<NewContent,string>|Text) extends string ? string : never,
+     *   (Extract<NewContent,string>|Text) extends never ? never : string,
      *   Schema
      * >}
      */
-    insert<NewContent extends AllowedDeltaFromSchema<Schema> extends Delta<any, any, infer Children_1, infer Text_1, infer Schema_1> ? ((Children_1 extends never ? never : Array<Children_1>) | Text_1) : never>(insert: NewContent, formatting?: FormattingAttributes | null, attribution?: Attribution | null): DeltaBuilder<NodeName, Attrs, Exclude<NewContent, string>[number] | Children, (Extract<NewContent, string> | Text) extends string ? string : never, Schema>;
+    insert<NewContent extends AllowedDeltaFromSchema<Schema> extends Delta<any, any, infer Children_1, infer Text_1, infer Schema_1> ? ((Children_1 extends never ? never : Array<Children_1>) | Text_1) : never>(insert: NewContent, formatting?: FormattingAttributes | null, attribution?: Attribution | null): DeltaBuilder<NodeName, Attrs, Exclude<NewContent, string>[number] | Children, (Extract<NewContent, string> | Text) extends never ? never : string, Schema>;
     /**
      * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,any,infer Children,any,any> ? Extract<Children,Delta<any,any,any,any,any>> : never} NewContent
      * @param {NewContent} modify
@@ -550,24 +741,29 @@ export class DeltaBuilder<NodeName extends string = any, Attrs extends {
      */
     apply(other: Delta<NodeName, Attrs, Children, Text, any>): this;
     /**
-     * @param {Delta<any,any,any,any,any>} other
+     * @param {DeltaAny} other
      * @param {boolean} priority
      */
-    rebase(other: Delta<any, any, any, any, any>, priority: boolean): this;
+    rebase(other: DeltaAny, priority: boolean): this;
     /**
-     * @return {Delta<NodeName,Attrs,Children,Text,Schema>}
+     * Same as doing `delta.rebase(other.inverse())`, without creating a temporary delta.
+     *
+     * @param {DeltaAny} other
+     * @param {boolean} priority
      */
-    done(): Delta<NodeName, Attrs, Children, Text, Schema>;
+    rebaseOnInverse(other: DeltaAny, priority: boolean): this;
 }
-export function $delta<NodeName_1 extends string = any, Attrs_1 extends {
-    [key: string | number | symbol]: any;
-} = {}, Children_1 extends unknown = never, HasText extends boolean = false, Recursive extends boolean = false>({ name, attrs, children, hasText, recursive }: {
-    name?: s.Schema<NodeName_1> | null | undefined;
-    attrs?: s.Schema<Attrs_1> | null | undefined;
-    children?: s.Schema<Children_1> | null | undefined;
-    hasText?: HasText | undefined;
+export function $delta<NodeNameSchema extends s.Schema<string> | string | Array<string> = s.Schema<any>, AttrsSchema extends s.Schema<{
+    [key: string | number]: any;
+}> | {
+    [key: string | number]: any;
+} = s.Schema<{}>, ChildrenSchema extends unknown = s.Schema<never>, HasText extends boolean = false, Recursive extends boolean = false>({ name, attrs, children, text, recursive }: {
+    name?: NodeNameSchema | null | undefined;
+    attrs?: AttrsSchema | null | undefined;
+    children?: ChildrenSchema | null | undefined;
+    text?: HasText | undefined;
     recursive?: Recursive | undefined;
-}): s.Schema<Delta<NodeName_1, Attrs_1, Children_1 | (Recursive extends true ? RecursiveDelta<NodeName_1, Attrs_1, Children_1, HasText extends true ? string : never> : never), HasText extends true ? string : never>>;
+}): [s.Unwrap<s.ReadSchema<NodeNameSchema>>, s.Unwrap<s.ReadSchema<AttrsSchema>>, s.Unwrap<s.ReadSchema<ChildrenSchema>>] extends [infer NodeName_1, infer Attrs_1, infer Children_1] ? s.Schema<Delta<NodeName_1, Attrs_1, Children_1 | (Recursive extends true ? RecursiveDelta<NodeName_1, Attrs_1, Children_1, HasText extends true ? string : never> : never), HasText extends true ? string : never>> : never;
 /**
  * @type {s.Schema<DeltaAny>}
  */
@@ -575,7 +771,7 @@ export const $deltaAny: s.Schema<DeltaAny>;
 export function mergeAttrs<T extends {
     [key: string]: any;
 }>(a: T | null, b: T | null): T | null;
-export function mergeDeltas<D extends DeltaBuilder | null>(a: D, b: D): D;
+export function mergeDeltas<D extends DeltaAny | null>(a: D, b: D): D;
 /**
  * @overload
  * @return {DeltaBuilder<any,{},never,never,null>}
@@ -606,8 +802,8 @@ export function create<NodeName extends string, Schema extends s.Schema<DeltaAny
 export function create<Schema extends s.Schema<DeltaAny>>(schema: Schema): Schema extends s.Schema<Delta<infer N, infer Attrs_1, infer Children_1, infer Text, any>> ? DeltaBuilder<N, Attrs_1, Children_1, Text, Schema> : never;
 /**
  * @template {string|null} NodeName
- * @template {{[k:string|number|symbol]:any}|null} Attrs
- * @template {Array<any>|string} Children
+ * @template {{[k:string|number]:any}|null} Attrs
+ * @template {Array<any>|string} [Children=never]
  * @overload
  * @param {NodeName} nodeName
  * @param {Attrs} attrs
@@ -621,17 +817,18 @@ export function create<Schema extends s.Schema<DeltaAny>>(schema: Schema): Schem
  * >}
  */
 export function create<NodeName extends string, Attrs extends {
-    [k: string | number | symbol]: any;
-} | null, Children extends Array<any> | string>(nodeName: NodeName, attrs: Attrs, children?: Children | undefined): DeltaBuilder<NodeName extends null ? any : NodeName, Attrs extends null ? {} : Attrs, Extract<Children, Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never, Extract<Children, string>, null>;
+    [k: string | number]: any;
+} | null, Children extends Array<any> | string = never>(nodeName: NodeName, attrs: Attrs, children?: Children | undefined): DeltaBuilder<NodeName extends null ? any : NodeName, Attrs extends null ? {} : Attrs, Extract<Children, Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never, Extract<Children, string>, null>;
 export function $text<$Embeds extends Array<s.Schema<any>> = any>(...$embeds: $Embeds): s.Schema<TextDelta<_AnyToNull<$Embeds> extends null ? never : ($Embeds extends Array<s.Schema<infer $C>> ? $C : never)>>;
 export const $textOnly: s.Schema<TextDelta<unknown>>;
 export function text<Schema_1 extends s.Schema<Delta<any, {}, any, any, null>> = s.Schema<Delta<any, {}, never, string, null>>>($schema?: Schema_1): Schema_1 extends s.Schema<Delta<infer N, infer Attrs_1, infer Children_1, infer Text, any>> ? DeltaBuilder<N, Attrs_1, Children_1, Text, Schema_1> : never;
-export function $array<$Children extends s.Schema<any>>($children?: $Children): s.Schema<ArrayDelta<$Children>>;
+export function $array<$Children extends unknown>($children?: $Children): s.Schema<ArrayDelta<s.Unwrap<s.ReadSchema<$Children>>>>;
 export function array<$Schema extends s.Schema<ArrayDelta<any>> = never>($schema: $Schema): $Schema extends never ? ArrayDeltaBuilder<never> : DeltaBuilder<any, {}, never, never, $Schema>;
 export function $map<$Attrs extends {
-    [K: string | number | symbol]: any;
+    [K: string | number]: any;
 }>($attrs: s.Schema<$Attrs>): s.Schema<MapDelta<$Attrs>>;
 export function map<$Schema extends s.Schema<MapDelta<any>> | undefined = undefined>($schema?: $Schema): $Schema extends s.Schema<MapDelta<infer Attrs_1>> ? DeltaBuilder<any, Attrs_1, never, never, $Schema> : MapDeltaBuilder<{}>;
+export function diff<D extends DeltaAny>(d1: D, d2: NoInfer<D>): D;
 export type Attribution = {
     insert?: string[];
     insertAt?: number;
@@ -640,13 +837,14 @@ export type Attribution = {
     format?: Record<string, string[]>;
     formatAt?: number;
 };
-export type DeltaOps = s.Unwrap<s.Schema<MapInsertOp<any, any> | InsertOp<any> | MapDeleteOp<any, string> | DeleteOp | TextOp | MapModifyOp<any, string> | ModifyOp<any>>>;
+export type DeltaOps = s.Unwrap<s.Schema<AttrInsertOp<any, any> | InsertOp<any> | AttrDeleteOp<any, string> | DeleteOp<never, never> | TextOp | AttrModifyOp<DeltaAny, string> | ModifyOp<DeltaAny>>>;
 export type FormattingAttributes = {
     [key: string]: any;
 };
 export type DeltaJSON = {
+    type: "delta";
     name?: string;
-    attrs?: { [Key in string | number | symbol]: DeltaAttrOpJSON; };
+    attrs?: { [Key in string | number]: DeltaAttrOpJSON; };
     children?: Array<DeltaListOpJSON>;
 };
 export type DeltaListOpJSON = {
@@ -682,30 +880,38 @@ export type DeltaAttrOpJSON = {
     type: "modify";
     value: DeltaJSON;
 };
+export type ChildrenOpAny = TextOp | InsertOp<any> | DeleteOp | RetainOp | ModifyOp<any>;
+export type AttrOpAny = AttrInsertOp<any> | AttrDeleteOp<any> | AttrModifyOp;
+export type _OpAny = ChildrenOpAny | AttrOpAny;
+export type Q = unknown & DeltaAny;
 export type MergeListArrays<C1 extends Array<any> | string, C2 extends Array<any> | string> = Extract<C1 | C2, Array<any>> extends never ? never : (Array<(Extract<C1 | C2, Array<any>> extends Array<infer AC1> ? (unknown extends AC1 ? never : AC1) : never)>);
-export type AddToAttrs<Attrs_1 extends { [Key in string | number | symbol]: any; }, Key extends string | number | symbol, Val extends unknown> = { [K in (Key | keyof Attrs_1)]: (unknown extends Attrs_1[K] ? never : Attrs_1[K]) | (Key extends K ? Val : never); };
+export type AddToAttrs<Attrs_1 extends { [Key in string | number]: any; }, Key extends string | number, Val extends unknown> = { [K in (Key | keyof Attrs_1)]: (unknown extends Attrs_1[K] ? never : Attrs_1[K]) | (Key extends K ? Val : never); };
 export type MergeAttrs<Attrs_1 extends { [Key in string | number | symbol]: any; }, NewAttrs extends { [Key in string | number | symbol]: any; }> = { [K in (keyof NewAttrs | keyof Attrs_1)]: (unknown extends Attrs_1[K] ? never : Attrs_1[K]) | (unknown extends NewAttrs[K] ? never : NewAttrs[K]); };
 export type _AnyToNull<X> = 0 extends (1 & X) ? null : X;
 export type AllowedDeltaFromSchema<Schema_1 extends s.Schema<Delta<any, any, any, any, any>> | null> = _AnyToNull<Schema_1> extends null ? Delta<any, {
-    [key: string | number | symbol]: any;
+    [key: string | number]: any;
 }, any, string> : (Schema_1 extends s.Schema<infer D> ? D : never);
 export type DeltaAny = Delta<any, {
-    [k: string]: any;
+    [k: string | number]: any;
+}, any, any, any>;
+export type DeltaBuilderAny = DeltaBuilder<any, {
+    [k: string | number]: any;
 }, any, any, any>;
 export type RecursiveDelta<NodeName_1 extends string, Attrs_1 extends {
-    [key: string | number | symbol]: any;
-} = {}, Children_1 extends unknown = never, Text extends string | never = never> = Delta<NodeName_1, Attrs_1, Children_1 | Delta<NodeName_1, Attrs_1, Children_1, Text> | RecursiveDelta<NodeName_1, Attrs_1, Children_1, Text>, Text>;
-export type TextDelta<Embeds = never> = Delta<any, {}, Embeds, string>;
-export type TextDeltaBuilder<Embeds = never> = DeltaBuilder<any, {}, Embeds, string>;
-export type ArrayDelta<Children_1 extends unknown> = Delta<any, {}, Children_1, never>;
-export type ArrayDeltaBuilder<Children_1 extends unknown> = DeltaBuilder<any, {}, Children_1, never>;
+    [key: string | number]: any;
+} = {}, Children_1 extends encoding.AnyEncodable | DeltaAny | never = never, Text extends string | never = never> = Delta<NodeName_1, Attrs_1, Children_1 | Delta<NodeName_1, Attrs_1, Children_1, Text> | RecursiveDelta<NodeName_1, Attrs_1, Children_1, Text>, Text>;
+export type TextDelta<Embeds extends encoding.AnyEncodable | DeltaAny = never> = Delta<any, {}, Embeds, string>;
+export type TextDeltaBuilder<Embeds extends encoding.AnyEncodable | DeltaAny = never> = DeltaBuilder<any, {}, Embeds, string>;
+export type ArrayDelta<Children_1 extends encoding.AnyEncodable | DeltaAny> = Delta<any, {}, Children_1, never>;
+export type ArrayDeltaBuilder<Children_1 extends encoding.AnyEncodable | DeltaAny> = DeltaBuilder<any, {}, Children_1, never>;
 export type MapDelta<Attrs_1 extends {
-    [K: string | number | symbol]: any;
+    [K: string | number]: any;
 }> = Delta<any, Attrs_1, never, never>;
 export type MapDeltaBuilder<Attrs_1 extends {
-    [K: string | number | symbol]: any;
+    [K: string | number]: any;
 }> = DeltaBuilder<any, Attrs_1, never, never>;
 import * as s from '../schema.js';
 import * as list from '../list.js';
 import * as traits from '../traits.js';
+import * as encoding from '../encoding.js';
 //# sourceMappingURL=d2.d.ts.map