lib0 0.2.112 → 0.2.115-0

package/delta/d2.d.ts

@@ -0,0 +1,705 @@
+/**
+ * @typedef {{
+ *   insert?: string[]
+ *   insertAt?: number
+ *   delete?: string[]
+ *   deleteAt?: number
+ *   format?: Record<string,string[]>
+ *   formatAt?: number
+ * }} Attribution
+ */
+/**
+ * @type {s.Schema<Attribution>}
+ */
+export const $attribution: s.Schema<Attribution>;
+/**
+ * @typedef {s.Unwrap<$anyOp>} DeltaOps
+ */
+/**
+ * @typedef {{ [key: string]: any }} FormattingAttributes
+ */
+/**
+ * @typedef {{
+ *   name?: string
+ *   attrs?: { [Key in string|number|symbol]: DeltaAttrOpJSON },
+ *   children?: Array<DeltaListOpJSON>
+ * }} DeltaJSON
+ */
+/**
+ * @typedef {{ insert: string|Array<any>, format?: { [key: string]: any }, attribution?: Attribution } | { delete: number } | { retain: number, format?: { [key:string]: any }, attribution?: Attribution } | { modify: object }} DeltaListOpJSON
+ */
+/**
+ * @typedef {{ type: 'insert', value: any, prevValue?: any, attribution?: Attribution } | { type: 'delete', prevValue?: any, attribution?: Attribution } | { type: 'modify', modify: DeltaJSON }} DeltaAttrOpJSON
+ */
+/**
+ * @type {s.Schema<DeltaAttrOpJSON>}
+ */
+export const $deltaMapChangeJson: s.Schema<DeltaAttrOpJSON>;
+export class TextOp extends list.ListNode {
+    /**
+     * @param {string} insert
+     * @param {FormattingAttributes|null} format
+     * @param {Attribution?} attribution
+     */
+    constructor(insert: string, format: FormattingAttributes | null, attribution: Attribution | null);
+    insert: string;
+    format: FormattingAttributes | null;
+    attribution: Attribution | null;
+    /**
+     * @return {'insert'}
+     */
+    get type(): "insert";
+    get length(): number;
+    /**
+     * Remove a part of the operation (similar to Array.splice)
+     *
+     * @param {number} offset
+     * @param {number} len
+     */
+    _splice(offset: number, len: number): void;
+    /**
+     * @return {DeltaListOpJSON}
+     */
+    toJSON(): DeltaListOpJSON;
+    /**
+     * @return {TextOp}
+     */
+    clone(): TextOp;
+    /**
+     * @param {TextOp} other
+     */
+    [traits.EqualityTraitSymbol](other: TextOp): boolean;
+}
+/**
+ * @template ArrayContent
+ */
+export class InsertOp<ArrayContent> 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;
+    /**
+     * @return {'insert'}
+     */
+    get type(): "insert";
+    get length(): number;
+    /**
+     * Remove a part of the operation (similar to Array.splice)
+     *
+     * @param {number} offset
+     * @param {number} len
+     */
+    _splice(offset: number, len: number): void;
+    /**
+     * @return {DeltaListOpJSON}
+     */
+    toJSON(): DeltaListOpJSON;
+    /**
+     * @return {InsertOp<ArrayContent>}
+     */
+    clone(): InsertOp<ArrayContent>;
+    /**
+     * @param {InsertOp<ArrayContent>} other
+     */
+    [traits.EqualityTraitSymbol](other: InsertOp<ArrayContent>): boolean;
+}
+export class DeleteOp extends list.ListNode {
+    /**
+     * @param {number} len
+     */
+    constructor(len: number);
+    delete: number;
+    /**
+     * @return {'delete'}
+     */
+    get type(): "delete";
+    get length(): number;
+    /**
+     * Remove a part of the operation (similar to Array.splice)
+     *
+     * @param {number} _offset
+     * @param {number} len
+     */
+    _splice(_offset: number, len: number): void;
+    /**
+     * @return {DeltaListOpJSON}
+     */
+    toJSON(): DeltaListOpJSON;
+    clone(): DeleteOp;
+    /**
+     * @param {DeleteOp} other
+     */
+    [traits.EqualityTraitSymbol](other: DeleteOp): boolean;
+}
+export class RetainOp extends list.ListNode {
+    /**
+     * @param {number} retain
+     * @param {FormattingAttributes|null} format
+     * @param {Attribution?} attribution
+     */
+    constructor(retain: number, format: FormattingAttributes | null, attribution: Attribution | null);
+    retain: number;
+    format: FormattingAttributes | null;
+    attribution: Attribution | null;
+    /**
+     * @return {'retain'}
+     */
+    get type(): "retain";
+    get length(): number;
+    /**
+     * Remove a part of the operation (similar to Array.splice)
+     *
+     * @param {number} _offset
+     * @param {number} len
+     */
+    _splice(_offset: number, len: number): void;
+    /**
+     * @return {DeltaListOpJSON}
+     */
+    toJSON(): DeltaListOpJSON;
+    clone(): RetainOp;
+    /**
+     * @param {RetainOp} other
+     */
+    [traits.EqualityTraitSymbol](other: RetainOp): boolean;
+}
+/**
+ * Delta that can be applied on a YType Embed
+ *
+ * @template {Delta<any,any,any,any,any>} DTypes
+ */
+export class ModifyOp<DTypes extends Delta<any, any, any, any, any>> extends list.ListNode {
+    /**
+     * @param {DTypes} delta
+     * @param {FormattingAttributes|null} format
+     * @param {Attribution?} attribution
+     */
+    constructor(delta: DTypes, format: FormattingAttributes | null, attribution: Attribution | null);
+    modify: DTypes;
+    format: FormattingAttributes | null;
+    attribution: Attribution | null;
+    /**
+     * @return {'modify'}
+     */
+    get type(): "modify";
+    get length(): number;
+    /**
+     * Remove a part of the operation (similar to Array.splice)
+     *
+     * @param {number} _offset
+     * @param {number} _len
+     */
+    _splice(_offset: number, _len: number): void;
+    /**
+     * @return {DeltaListOpJSON}
+     */
+    toJSON(): DeltaListOpJSON;
+    /**
+     * @return {ModifyOp<DTypes>}
+     */
+    clone(): ModifyOp<DTypes>;
+    /**
+     * @param {ModifyOp<any>} other
+     */
+    [traits.EqualityTraitSymbol](other: ModifyOp<any>): boolean;
+}
+/**
+ * @template V
+ * @template [K=string]
+ */
+export class MapInsertOp<V, K = string> {
+    /**
+     * @param {K} key
+     * @param {V} value
+     * @param {V|undefined} prevValue
+     * @param {Attribution?} attribution
+     */
+    constructor(key: K, value: V, prevValue: V | undefined, attribution: Attribution | null);
+    /**
+     * @type {K}
+     */
+    key: K;
+    /**
+     * @type {V}
+     */
+    value: V;
+    /**
+     * @type {V|undefined}
+     */
+    prevValue: V | undefined;
+    attribution: Attribution | null;
+    /**
+     * @return {'insert'}
+     */
+    get type(): "insert";
+    toJSON(): {
+        type: "insert";
+        value: V | DeltaJSON;
+    } & (({
+        attribution: Attribution;
+    } | {
+        attribution?: undefined;
+    }) & ({
+        prevValue: V & ({} | null);
+    } | {
+        prevValue?: undefined;
+    }));
+    /**
+     * @return {MapInsertOp<V,K>}
+     */
+    clone(): MapInsertOp<V, K>;
+    /**
+     * @param {MapInsertOp<V>} other
+     */
+    [traits.EqualityTraitSymbol](other: MapInsertOp<V>): boolean;
+}
+/**
+ * @template V
+ * @template [K=string]
+ */
+export class MapDeleteOp<V, K = string> {
+    /**
+     * @param {K} key
+     * @param {V|undefined} prevValue
+     * @param {Attribution?} attribution
+     */
+    constructor(key: K, prevValue: V | undefined, attribution: Attribution | null);
+    /**
+     * @type {K}
+     */
+    key: K;
+    /**
+     * @type {V|undefined}
+     */
+    prevValue: V | undefined;
+    attribution: Attribution | null;
+    get value(): undefined;
+    /**
+     * @type {'delete'}
+     */
+    get type(): "delete";
+    /**
+     * @return {DeltaAttrOpJSON}
+     */
+    toJSON(): DeltaAttrOpJSON;
+    clone(): MapDeleteOp<V, K>;
+    /**
+     * @param {MapDeleteOp<V>} other
+     */
+    [traits.EqualityTraitSymbol](other: MapDeleteOp<V>): boolean;
+}
+/**
+ * @template {Delta} Modifier
+ * @template [K=string]
+ */
+export class MapModifyOp<Modifier extends Delta, K = string> {
+    /**
+     * @param {K} key
+     * @param {Modifier} delta
+     */
+    constructor(key: K, delta: Modifier);
+    /**
+     * @type {K}
+     */
+    key: K;
+    /**
+     * @type {Modifier}
+     */
+    value: Modifier;
+    /**
+     * @type {'modify'}
+     */
+    get type(): "modify";
+    /**
+     * @return {DeltaAttrOpJSON}
+     */
+    toJSON(): DeltaAttrOpJSON;
+    /**
+     * @return {MapModifyOp<Modifier,K>}
+     */
+    clone(): MapModifyOp<Modifier, K>;
+    /**
+     * @param {MapModifyOp<Modifier>} other
+     */
+    [traits.EqualityTraitSymbol](other: MapModifyOp<Modifier>): boolean;
+}
+/**
+ * @type {s.Schema<MapDeleteOp<any> | DeleteOp>}
+ */
+export const $deleteOp: s.Schema<MapDeleteOp<any> | DeleteOp>;
+/**
+ * @type {s.Schema<MapInsertOp<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>>;
+/**
+ * @type {s.Schema<TextOp>}
+ */
+export const $textOp: s.Schema<TextOp>;
+/**
+ * @type {s.Schema<RetainOp>}
+ */
+export const $retainOp: s.Schema<RetainOp>;
+/**
+ * @type {s.Schema<MapModifyOp<any> | ModifyOp<any>>}
+ */
+export const $modifyOp: s.Schema<MapModifyOp<any> | ModifyOp<any>>;
+export function $modifyOpWith<Modify extends Delta>($content: s.Schema<Modify>): s.Schema<MapModifyOp<Modify> | ModifyOp<Modify>>;
+export const $anyOp: s.Schema<MapInsertOp<any, string> | InsertOp<any> | MapDeleteOp<any, string> | DeleteOp | TextOp | MapModifyOp<any, string> | ModifyOp<any>>;
+/**
+ * @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|symbol]: any}} Attrs
+ * @template {string|number|symbol} 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|symbol]:any},any,string> : (Schema extends s.Schema<infer D> ? D : never)} AllowedDeltaFromSchema
+ */
+/**
+ * @template {string} [NodeName=any]
+ * @template {{[key:string|number|symbol]:any}} [out Attrs={}]
+ * @template {any} [out Children=never]
+ * @template {string|never} [out Text=never]
+ * @template {s.Schema<Delta<any,any,any,any,any>>|null} [Schema=any]
+ */
+export class Delta<NodeName extends string = any, out Attrs extends {
+    [key: string | number | symbol]: any;
+} = {}, out Children extends unknown = never, out Text extends string | never = never, Schema extends s.Schema<Delta<any, any, any, any, any>> | null = any> {
+    /**
+     * @param {NodeName} [name]
+     * @param {Schema} [$schema]
+     */
+    constructor(name?: NodeName, $schema?: Schema);
+    name: NodeName | null;
+    $schema: NonNullable<Schema> | null;
+    /**
+     * @type {Map<keyof Attrs, { [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: Map<keyof Attrs, { [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 {list.List<
+     *   RetainOp
+     *   | DeleteOp
+     *   | (Text extends never ? never : TextOp)
+     *   | (Children extends never ? never : InsertOp<Children>)
+     *   | (Delta extends Children ? ModifyOp<Extract<Children,Delta>> : never)
+     * >}
+     */
+    children: list.List<RetainOp | DeleteOp | (Text extends never ? never : TextOp) | (Children extends never ? never : InsertOp<Children>) | (Delta extends Children ? ModifyOp<Extract<Children, Delta>> : never)>;
+    /**
+     * @type {FormattingAttributes?}
+     */
+    usedAttributes: FormattingAttributes | null;
+    /**
+     * @type {Attribution?}
+     */
+    usedAttribution: Attribution | null;
+    /**
+     * @type {any}
+     */
+    origin: any;
+    isEmpty(): boolean;
+    /**
+     * @return {DeltaJSON}
+     */
+    toJSON(): DeltaJSON;
+    /**
+     * @param {Delta<any,any,any,any,any>} other
+     * @return {boolean}
+     */
+    equals(other: Delta<any, any, any, any, any>): boolean;
+    /**
+     * @return {this}
+     */
+    clone(): this;
+    /**
+     * @param {Attribution?} attribution
+     */
+    useAttribution(attribution: Attribution | null): this;
+    /**
+     * @param {FormattingAttributes?} attributes
+     * @return {this}
+     */
+    useAttributes(attributes: FormattingAttributes | null): this;
+    /**
+     * @param {string} name
+     * @param {any} value
+     */
+    updateUsedAttributes(name: string, value: any): this;
+    /**
+     * @template {keyof Attribution} NAME
+     * @param {NAME} name
+     * @param {Attribution[NAME]?} value
+     */
+    updateUsedAttribution<NAME extends keyof Attribution>(name: NAME, value: Attribution[NAME] | null): this;
+    /**
+     * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,any,infer Children,infer Text,infer Schema> ? ((Children extends never ? never : Array<Children>) | Text) : never} NewContent
+     * @param {NewContent} insert
+     * @param {FormattingAttributes?} [formatting]
+     * @param {Attribution?} [attribution]
+     * @return {Delta<
+     *   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): Delta<NodeName, Attrs, Exclude<NewContent, string>[number] | Children, (Extract<NewContent, string> | Text) extends string ? string : never, 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
+     * @param {FormattingAttributes?} formatting
+     * @param {Attribution?} attribution
+     * @return {Delta<
+     *   NodeName,
+     *   Attrs,
+     *   Exclude<NewContent,string>[number]|Children,
+     *   (Extract<NewContent,string>|Text) extends string ? string : never,
+     *   Schema
+     * >}
+     */
+    modify<NewContent extends AllowedDeltaFromSchema<Schema> extends Delta<any, any, infer Children_1, any, any> ? Extract<Children_1, Delta<any, any, any, any, any>> : never>(modify: NewContent, formatting?: FormattingAttributes | null, attribution?: Attribution | null): Delta<NodeName, Attrs, Exclude<NewContent, string>[number] | Children, (Extract<NewContent, string> | Text) extends string ? string : never, Schema>;
+    /**
+     * @param {number} len
+     * @param {FormattingAttributes?} [format]
+     * @param {Attribution?} [attribution]
+     */
+    retain(len: number, format?: FormattingAttributes | null, attribution?: Attribution | null): this;
+    /**
+     * @param {number} len
+     * @return {this}
+     */
+    delete(len: number): this;
+    /**
+     * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer Attrs,any,any,any> ? (keyof Attrs) : never} Key
+     * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer Attrs,any,any,any> ? (Attrs[Key]) : never} Val
+     * @param {Key} key
+     * @param {Val} val
+     * @param {Attribution?} attribution
+     * @param {Val|undefined} [prevValue]
+     * @return {Delta<
+     *   NodeName,
+     *   { [K in keyof AddToAttrs<Attrs,Key,Val>]: AddToAttrs<Attrs,Key,Val>[K]  },
+     *   Children,
+     *   Text,
+     *   Schema
+     * >}
+     */
+    set<Key extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer Attrs_1, any, any, any> ? (keyof Attrs_1) : never, Val extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer Attrs_1, any, any, any> ? (Attrs_1[Key]) : never>(key: Key, val: Val, attribution?: Attribution | null, prevValue?: Val | undefined): Delta<NodeName, { [K in keyof AddToAttrs<Attrs, Key, Val>]: AddToAttrs<Attrs, Key, Val>[K]; }, Children, Text, Schema>;
+    /**
+     * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer Attrs,any,any,any> ? Attrs : never} NewAttrs
+     * @param {NewAttrs} attrs
+     * @param {Attribution?} attribution
+     * @return {Delta<
+     *   NodeName,
+     *   { [K in keyof MergeAttrs<Attrs,NewAttrs>]: MergeAttrs<Attrs,NewAttrs>[K] },
+     *   Children,
+     *   Text,
+     *   Schema
+     * >}
+     */
+    setMany<NewAttrs extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer Attrs_1, any, any, any> ? Attrs_1 : never>(attrs: NewAttrs, attribution?: Attribution | null): Delta<NodeName, { [K in keyof MergeAttrs<Attrs, NewAttrs>]: MergeAttrs<Attrs, NewAttrs>[K]; }, Children, Text, Schema>;
+    /**
+     * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer As,any,any,any> ? keyof As : never} Key
+     * @param {Key} key
+     * @param {Attribution?} attribution
+     * @param {any} [prevValue]
+     * @return {Delta<
+     *   NodeName,
+     *   { [K in keyof AddToAttrs<Attrs,Key,never>]: AddToAttrs<Attrs,Key,never>[K] },
+     *   Children,
+     *   Text,
+     *   Schema
+     * >}
+     */
+    unset<Key extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer As, any, any, any> ? keyof As : never>(key: Key, attribution?: Attribution | null, prevValue?: any): Delta<NodeName, { [K in keyof AddToAttrs<Attrs, Key, never>]: AddToAttrs<Attrs, Key, never>[K]; }, Children, Text, Schema>;
+    /**
+     * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer As,any,any,any> ? { [K in keyof As]: Extract<As[K],Delta<any,any,any,any,any>> extends never ? never : K }[keyof As] : never} Key
+     * @template {AllowedDeltaFromSchema<Schema> extends Delta<any,infer As,any,any,any> ? Extract<As[Key],Delta<any,any,any,any,any>> : never} D
+     * @param {Key} key
+     * @param {D} modify
+     * @return {Delta<
+     *   NodeName,
+     *   { [K in keyof AddToAttrs<Attrs,Key,D>]: AddToAttrs<Attrs,Key,D>[K]  },
+     *   Children,
+     *   Text,
+     *   Schema
+     * >}
+     */
+    update<Key extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer As, any, any, any> ? { [K in keyof As]: Extract<As[K], Delta<any, any, any, any, any>> extends never ? never : K; }[keyof As] : never, D extends AllowedDeltaFromSchema<Schema> extends Delta<any, infer As, any, any, any> ? Extract<As[Key], Delta<any, any, any, any, any>> : never>(key: Key, modify: D): Delta<NodeName, { [K in keyof AddToAttrs<Attrs, Key, D>]: AddToAttrs<Attrs, Key, D>[K]; }, Children, Text, Schema>;
+    /**
+     * @param {Delta<NodeName,Partial<Attrs>,Children,Text,any>} other
+     * @return {this}
+     */
+    apply(other: Delta<NodeName, Partial<Attrs>, Children, Text, any>): this;
+    /**
+     * @param {Delta<any,any,any,any,any>} other
+     * @param {boolean} priority
+     */
+    rebase(other: Delta<any, any, any, any, any>, priority: boolean): this;
+    done(): this;
+    /**
+     * @param {any} other
+     * @return {boolean}
+     */
+    [traits.EqualityTraitSymbol](other: any): boolean;
+}
+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;
+    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>>;
+export const $deltaAny: s.Schema<Delta<any, {}, never, never, any>>;
+export function mergeAttrs<T extends {
+    [key: string]: any;
+}>(a: T | null, b: T | null): T | null;
+export function mergeDeltas<D extends Delta | null>(a: D, b: D): D;
+/**
+ * @overload
+ * @return {Delta<any,{},never,never,null>}
+ */
+export function create(): Delta<any, {}, never, never, null>;
+/**
+ * @template {string} NodeName
+ * @overload
+ * @param {NodeName} nodeName
+ * @return {Delta<NodeName,{},never,never,null>}
+ */
+export function create<NodeName extends string>(nodeName: NodeName): Delta<NodeName, {}, never, never, null>;
+/**
+ * @template {string} NodeName
+ * @template {s.Schema<Delta<any,any,any,any,any>>} Schema
+ * @overload
+ * @param {NodeName} nodeName
+ * @param {Schema} schema
+ * @return {Schema extends s.Schema<Delta<infer N,infer Attrs,infer Children,infer Text,any>> ? Delta<NodeName,Attrs,Children,Text,Schema> : never}
+ */
+export function create<NodeName extends string, Schema extends s.Schema<Delta<any, any, any, any, any>>>(nodeName: NodeName, schema: Schema): Schema extends s.Schema<Delta<infer N, infer Attrs_1, infer Children_1, infer Text, any>> ? Delta<NodeName, Attrs_1, Children_1, Text, Schema> : never;
+/**
+ * @template {s.Schema<Delta<any,any,any,any,any>>} Schema
+ * @overload
+ * @param {Schema} schema
+ * @return {Schema extends s.Schema<Delta<infer N,infer Attrs,infer Children,infer Text,any>> ? Delta<N,Attrs,Children,Text,Schema> : never}
+ */
+export function create<Schema extends s.Schema<Delta<any, any, any, any, any>>>(schema: Schema): Schema extends s.Schema<Delta<infer N, infer Attrs_1, infer Children_1, infer Text, any>> ? Delta<N, Attrs_1, Children_1, Text, Schema> : never;
+/**
+ * @template {string|null} NodeName
+ * @template {{[k:string|number|symbol]:any}|null} Attrs
+ * @template {Array<Array<any>|string>} Children
+ * @overload
+ * @param {NodeName} nodeName
+ * @param {Attrs} attrs
+ * @param {...Children} children
+ * @return {Delta<
+ *   NodeName extends null ? any : NodeName,
+ *   Attrs extends null ? {} : Attrs,
+ *   Extract<Children[number],Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never,
+ *   Extract<Children[number],string>,
+ *   null
+ * >}
+ */
+export function create<NodeName extends string, Attrs extends {
+    [k: string | number | symbol]: any;
+} | null, Children extends Array<Array<any> | string>>(nodeName: NodeName, attrs: Attrs, ...children: Children[]): Delta<NodeName extends null ? any : NodeName, Attrs extends null ? {} : Attrs, Extract<Children[number], Array<any>> extends Array<infer Ac> ? (unknown extends Ac ? never : Ac) : never, Extract<Children[number], 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>> ? Delta<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<$Schema extends s.Schema<ArrayDelta<any>> = never>($schema: $Schema): $Schema extends never ? ArrayDelta<never> : Delta<any, {}, never, never, $Schema>;
+export function $map<$Attrs extends {
+    [K: string | number | symbol]: 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>> ? Delta<any, Attrs_1, never, never, $Schema> : MapDelta<{}>;
+export type Attribution = {
+    insert?: string[];
+    insertAt?: number;
+    delete?: string[];
+    deleteAt?: number;
+    format?: Record<string, string[]>;
+    formatAt?: number;
+};
+export type DeltaOps = s.Unwrap<s.Schema<MapInsertOp<any, string> | InsertOp<any> | MapDeleteOp<any, string> | DeleteOp | TextOp | MapModifyOp<any, string> | ModifyOp<any>>>;
+export type FormattingAttributes = {
+    [key: string]: any;
+};
+export type DeltaJSON = {
+    name?: string;
+    attrs?: { [Key in string | number | symbol]: DeltaAttrOpJSON; };
+    children?: Array<DeltaListOpJSON>;
+};
+export type DeltaListOpJSON = {
+    insert: string | Array<any>;
+    format?: {
+        [key: string]: any;
+    };
+    attribution?: Attribution;
+} | {
+    delete: number;
+} | {
+    retain: number;
+    format?: {
+        [key: string]: any;
+    };
+    attribution?: Attribution;
+} | {
+    modify: object;
+};
+export type DeltaAttrOpJSON = {
+    type: "insert";
+    value: any;
+    prevValue?: any;
+    attribution?: Attribution;
+} | {
+    type: "delete";
+    prevValue?: any;
+    attribution?: Attribution;
+} | {
+    type: "modify";
+    modify: DeltaJSON;
+};
+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 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;
+}, any, string> : (Schema_1 extends s.Schema<infer D> ? D : never);
+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 | RecursiveDelta<NodeName_1, Attrs_1, Children_1>, Text>;
+export type TextDelta<Embeds = never> = Delta<any, {}, Embeds, string>;
+export type ArrayDelta<Children_1 extends unknown> = Delta<any, {}, Children_1, never>;
+export type MapDelta<Attrs_1 extends {
+    [K: string | number | symbol]: any;
+}> = Delta<any, Attrs_1, never, never>;
+import * as s from '../schema.js';
+import * as list from '../list.js';
+import * as traits from '../traits.js';
+//# sourceMappingURL=d2.d.ts.map