@fluidframework/tree 2.80.0 → 2.81.0

package/dist/text/textDomainFormatted.d.ts

@@ -0,0 +1,572 @@
+/*!
+ * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
+ * Licensed under the MIT License.
+ */
+import type { InsertableTypedNode, TreeNode, TreeNodeFromImplicitAllowedTypes, WithType } from "../simple-tree/index.js";
+import { type TextAsTree } from "./textDomain.js";
+/**
+ * A collection of text related types, schema and utilities for working with text beyond the basic {@link SchemaStatics.string}.
+ * @privateRemarks
+ * This has hard-coded assumptions about what kind of embedded content and what kind of formatting is supported.
+ * We will want to generalize this with a more generic schema factory function like with table.
+ * Then either that and/or the output from it can be package exported.
+ * This version is just an initial prototype.
+ * @internal
+ */
+export declare namespace FormattedTextAsTree {
+    const CharacterFormat_base: import("../simple-tree/index.js").ObjectNodeSchema<"com.fluidframework.text.formatted.CharacterFormat", {
+        readonly bold: import("../simple-tree/leafNodeSchema.js").LeafSchema<"boolean", boolean>;
+        readonly italic: import("../simple-tree/leafNodeSchema.js").LeafSchema<"boolean", boolean>;
+        readonly underline: import("../simple-tree/leafNodeSchema.js").LeafSchema<"boolean", boolean>;
+        readonly size: import("../simple-tree/leafNodeSchema.js").LeafSchema<"number", number>;
+        readonly font: import("../simple-tree/leafNodeSchema.js").LeafSchema<"string", string>;
+    }, true, unknown> & {
+        readonly createFromInsertable: unknown;
+    };
+    /**
+     * Formatting options for characters.
+     * @internal
+     */
+    export class CharacterFormat extends CharacterFormat_base {
+    }
+    const StringTextAtom_base: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.StringTextAtom", import("../simple-tree/index.js").NodeKind.Object, import("../simple-tree/index.js").TreeObjectNode<{
+        /**
+         * The underlying text content of this atom.
+         * @remarks
+         * This is typically a single unicode codepoint, and thus may contain multiple utf-16 surrogate pair code units.
+         * Using longer strings is still valid. For example, so users might store whole grapheme clusters here, or even longer sections of text.
+         * Anything combined into a single atom will be treated atomically, and can not be partially selected or formatted.
+         * Using larger atoms and splitting them as needed is NOT a recommended approach, since this will result in poor merge behavior for concurrent edits.
+         * Instead atoms should always be the smallest unit of text which will be independently selected, moved or formatted.
+         * @privateRemarks
+         * This content logically represents the whole atom's content, so using {@link EmptyKey} makes sense to help indicate that.
+         */
+        readonly content: import("../simple-tree/fieldSchema.js").FieldSchema<import("../simple-tree/fieldSchema.js").FieldKind.Required, readonly [import("../simple-tree/leafNodeSchema.js").LeafSchema<"string", string>], unknown>;
+    }, "com.fluidframework.text.formatted.StringTextAtom">, object & {
+        readonly content: string;
+    }, true, {
+        /**
+         * The underlying text content of this atom.
+         * @remarks
+         * This is typically a single unicode codepoint, and thus may contain multiple utf-16 surrogate pair code units.
+         * Using longer strings is still valid. For example, so users might store whole grapheme clusters here, or even longer sections of text.
+         * Anything combined into a single atom will be treated atomically, and can not be partially selected or formatted.
+         * Using larger atoms and splitting them as needed is NOT a recommended approach, since this will result in poor merge behavior for concurrent edits.
+         * Instead atoms should always be the smallest unit of text which will be independently selected, moved or formatted.
+         * @privateRemarks
+         * This content logically represents the whole atom's content, so using {@link EmptyKey} makes sense to help indicate that.
+         */
+        readonly content: import("../simple-tree/fieldSchema.js").FieldSchema<import("../simple-tree/fieldSchema.js").FieldKind.Required, readonly [import("../simple-tree/leafNodeSchema.js").LeafSchema<"string", string>], unknown>;
+    }, never, unknown>;
+    /**
+     * Unit in the string representing a single character.
+     * @internal
+     */
+    export class StringTextAtom extends StringTextAtom_base {
+    }
+    /**
+     * Tag with which a line in text can be formatted from HTML.
+     * @internal
+     */
+    export const LineTag: (<TValue extends "li" | "h1" | "h2" | "h3" | "h4" | "h5">(value: TValue) => TValue extends unknown ? TreeNode & {
+        readonly value: TValue;
+    } : never) & {
+        h1: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.h1" | "com.h1", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
+            readonly value: "h1";
+        }, Record<string, never>, true, Record<string, never>, undefined>;
+        h3: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.h3" | "com.h3", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
+            readonly value: "h3";
+        }, Record<string, never>, true, Record<string, never>, undefined>;
+        h2: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.h2" | "com.h2", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
+            readonly value: "h2";
+        }, Record<string, never>, true, Record<string, never>, undefined>;
+        h5: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.h5" | "com.h5", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
+            readonly value: "h5";
+        }, Record<string, never>, true, Record<string, never>, undefined>;
+        h4: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.h4" | "com.h4", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
+            readonly value: "h4";
+        }, Record<string, never>, true, Record<string, never>, undefined>;
+        li: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.li" | "com.li", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
+            readonly value: "li";
+        }, Record<string, never>, true, Record<string, never>, undefined>;
+    } & {
+        readonly schema: [import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.li" | "com.li", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
+            readonly value: "li";
+        }, Record<string, never>, true, Record<string, never>, undefined>, import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h1" | "com.h1", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h1";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h2" | "com.h2", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h2";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h3" | "com.h3", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h3";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h4" | "com.h4", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h4";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h5" | "com.h5", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h5";
+        })];
+    };
+    /**
+     * {@inheritdoc FormattedTextAsTree.(LineTag:variable)}
+     * @internal
+     */
+    export type LineTag = TreeNodeFromImplicitAllowedTypes<typeof LineTag.schema>;
+    const StringLineAtom_base: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.StringLineAtom", import("../simple-tree/index.js").NodeKind.Object, import("../simple-tree/index.js").TreeObjectNode<{
+        readonly tag: [import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.li" | "com.li", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
+            readonly value: "li";
+        }, Record<string, never>, true, Record<string, never>, undefined>, import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h1" | "com.h1", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h1";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h2" | "com.h2", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h2";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h3" | "com.h3", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h3";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h4" | "com.h4", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h4";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h5" | "com.h5", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h5";
+        })];
+    }, "com.fluidframework.text.formatted.StringLineAtom">, object & {
+        readonly tag: Record<string, never> | (Record<string, never> & TreeNode & {
+            readonly value: "li";
+        }) | (Record<string, never> & TreeNode & {
+            readonly value: "h1";
+        }) | (Record<string, never> & TreeNode & {
+            readonly value: "h2";
+        }) | (Record<string, never> & TreeNode & {
+            readonly value: "h3";
+        }) | (Record<string, never> & TreeNode & {
+            readonly value: "h4";
+        }) | (Record<string, never> & TreeNode & {
+            readonly value: "h5";
+        }) | (TreeNode & {
+            readonly value: "li";
+        } & Record<string, never>) | (TreeNode & {
+            readonly value: "li";
+        }) | (TreeNode & {
+            readonly value: "h1";
+        } & Record<string, never>) | (TreeNode & {
+            readonly value: "h1";
+        }) | (TreeNode & {
+            readonly value: "h2";
+        } & Record<string, never>) | (TreeNode & {
+            readonly value: "h2";
+        }) | (TreeNode & {
+            readonly value: "h3";
+        } & Record<string, never>) | (TreeNode & {
+            readonly value: "h3";
+        }) | (TreeNode & {
+            readonly value: "h4";
+        } & Record<string, never>) | (TreeNode & {
+            readonly value: "h4";
+        }) | (TreeNode & {
+            readonly value: "h5";
+        } & Record<string, never>) | (TreeNode & {
+            readonly value: "h5";
+        });
+    }, true, {
+        readonly tag: [import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.lineTag.li" | "com.li", import("../simple-tree/index.js").NodeKind.Object, TreeNode & {
+            readonly value: "li";
+        }, Record<string, never>, true, Record<string, never>, undefined>, import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h1" | "com.h1", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h1";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h2" | "com.h2", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h2";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h3" | "com.h3", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h3";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h4" | "com.h4", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h4";
+        }), import("../simple-tree/index.js").TreeNodeSchemaCore<"com.fluidframework.text.formatted.lineTag.h5" | "com.h5", import("../simple-tree/index.js").NodeKind.Object, true, Record<string, never>, Record<string, never>, unknown> & (new (data?: Record<string, never> | import("../simple-tree/index.js").InternalTreeNode | undefined) => TreeNode & {
+            readonly value: "h5";
+        })];
+    }, never, unknown>;
+    /**
+     * Unit in the string representing a new line character with line formatting.
+     * @remarks
+     * This aligns with how Quill represents line formatting.
+     * Note that not all new lines will use this,
+     * but only ones using this can have line specific formatting.
+     * @internal
+     */
+    export class StringLineAtom extends StringLineAtom_base {
+        readonly content = "\n";
+    }
+    /**
+     * Types of "atoms" that make up the text.
+     * @internal
+     */
+    export const StringAtomContent: readonly [typeof StringTextAtom, typeof StringLineAtom];
+    /**
+     * {@inheritdoc FormattedTextAsTree.(StringAtomContent:variable)}
+     * @internal
+     */
+    export type StringAtomContent = TreeNodeFromImplicitAllowedTypes<typeof StringAtomContent>;
+    const StringAtom_base: import("../simple-tree/index.js").TreeNodeSchemaClass<"com.fluidframework.text.formatted.StringAtom", import("../simple-tree/index.js").NodeKind.Object, import("../simple-tree/index.js").TreeObjectNode<{
+        readonly content: import("../simple-tree/fieldSchema.js").FieldSchema<import("../simple-tree/fieldSchema.js").FieldKind.Required, readonly [typeof StringTextAtom, typeof StringLineAtom], unknown>;
+        readonly format: typeof CharacterFormat;
+    }, "com.fluidframework.text.formatted.StringAtom">, object & {
+        readonly content: StringTextAtom | (object & {
+            readonly content: string;
+        }) | StringLineAtom | (object & {
+            readonly tag: Record<string, never> | (Record<string, never> & TreeNode & {
+                readonly value: "li";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h1";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h2";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h3";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h4";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h5";
+            }) | (TreeNode & {
+                readonly value: "li";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "li";
+            }) | (TreeNode & {
+                readonly value: "h1";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h1";
+            }) | (TreeNode & {
+                readonly value: "h2";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h2";
+            }) | (TreeNode & {
+                readonly value: "h3";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h3";
+            }) | (TreeNode & {
+                readonly value: "h4";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h4";
+            }) | (TreeNode & {
+                readonly value: "h5";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h5";
+            });
+        }) | (StringTextAtom & object & {
+            readonly content: string;
+        }) | (StringTextAtom & object & {
+            readonly tag: Record<string, never> | (Record<string, never> & TreeNode & {
+                readonly value: "li";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h1";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h2";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h3";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h4";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h5";
+            }) | (TreeNode & {
+                readonly value: "li";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "li";
+            }) | (TreeNode & {
+                readonly value: "h1";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h1";
+            }) | (TreeNode & {
+                readonly value: "h2";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h2";
+            }) | (TreeNode & {
+                readonly value: "h3";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h3";
+            }) | (TreeNode & {
+                readonly value: "h4";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h4";
+            }) | (TreeNode & {
+                readonly value: "h5";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h5";
+            });
+        }) | (object & {
+            readonly content: string;
+        } & StringTextAtom) | (object & {
+            readonly content: string;
+        } & StringLineAtom) | (object & {
+            readonly content: string;
+        } & {
+            readonly tag: Record<string, never> | (Record<string, never> & TreeNode & {
+                readonly value: "li";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h1";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h2";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h3";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h4";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h5";
+            }) | (TreeNode & {
+                readonly value: "li";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "li";
+            }) | (TreeNode & {
+                readonly value: "h1";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h1";
+            }) | (TreeNode & {
+                readonly value: "h2";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h2";
+            }) | (TreeNode & {
+                readonly value: "h3";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h3";
+            }) | (TreeNode & {
+                readonly value: "h4";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h4";
+            }) | (TreeNode & {
+                readonly value: "h5";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h5";
+            });
+        }) | (StringLineAtom & object & {
+            readonly content: string;
+        }) | (StringLineAtom & object & {
+            readonly tag: Record<string, never> | (Record<string, never> & TreeNode & {
+                readonly value: "li";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h1";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h2";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h3";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h4";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h5";
+            }) | (TreeNode & {
+                readonly value: "li";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "li";
+            }) | (TreeNode & {
+                readonly value: "h1";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h1";
+            }) | (TreeNode & {
+                readonly value: "h2";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h2";
+            }) | (TreeNode & {
+                readonly value: "h3";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h3";
+            }) | (TreeNode & {
+                readonly value: "h4";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h4";
+            }) | (TreeNode & {
+                readonly value: "h5";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h5";
+            });
+        }) | (object & {
+            readonly tag: Record<string, never> | (Record<string, never> & TreeNode & {
+                readonly value: "li";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h1";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h2";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h3";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h4";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h5";
+            }) | (TreeNode & {
+                readonly value: "li";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "li";
+            }) | (TreeNode & {
+                readonly value: "h1";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h1";
+            }) | (TreeNode & {
+                readonly value: "h2";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h2";
+            }) | (TreeNode & {
+                readonly value: "h3";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h3";
+            }) | (TreeNode & {
+                readonly value: "h4";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h4";
+            }) | (TreeNode & {
+                readonly value: "h5";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h5";
+            });
+        } & StringTextAtom) | (object & {
+            readonly tag: Record<string, never> | (Record<string, never> & TreeNode & {
+                readonly value: "li";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h1";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h2";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h3";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h4";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h5";
+            }) | (TreeNode & {
+                readonly value: "li";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "li";
+            }) | (TreeNode & {
+                readonly value: "h1";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h1";
+            }) | (TreeNode & {
+                readonly value: "h2";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h2";
+            }) | (TreeNode & {
+                readonly value: "h3";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h3";
+            }) | (TreeNode & {
+                readonly value: "h4";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h4";
+            }) | (TreeNode & {
+                readonly value: "h5";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h5";
+            });
+        } & {
+            readonly content: string;
+        }) | (object & {
+            readonly tag: Record<string, never> | (Record<string, never> & TreeNode & {
+                readonly value: "li";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h1";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h2";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h3";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h4";
+            }) | (Record<string, never> & TreeNode & {
+                readonly value: "h5";
+            }) | (TreeNode & {
+                readonly value: "li";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "li";
+            }) | (TreeNode & {
+                readonly value: "h1";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h1";
+            }) | (TreeNode & {
+                readonly value: "h2";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h2";
+            }) | (TreeNode & {
+                readonly value: "h3";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h3";
+            }) | (TreeNode & {
+                readonly value: "h4";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h4";
+            }) | (TreeNode & {
+                readonly value: "h5";
+            } & Record<string, never>) | (TreeNode & {
+                readonly value: "h5";
+            });
+        } & StringLineAtom);
+        readonly format: (InsertableTypedNode<typeof CharacterFormat> | undefined) & InsertableTypedNode<typeof CharacterFormat>;
+    }, true, {
+        readonly content: import("../simple-tree/fieldSchema.js").FieldSchema<import("../simple-tree/fieldSchema.js").FieldKind.Required, readonly [typeof StringTextAtom, typeof StringLineAtom], unknown>;
+        readonly format: typeof CharacterFormat;
+    }, never, unknown>;
+    /**
+     * A unit of the text, with formatting.
+     * @internal
+     */
+    export class StringAtom extends StringAtom_base {
+    }
+    /**
+     * Statics for text nodes.
+     * @internal
+     */
+    export interface Statics {
+        /**
+         * Construct a {@link FormattedTextAsTree.(Tree:type)} from a string, where each character (as defined by iterating over the string) becomes a single character in the text node.
+         * @remarks This combines pairs of utf-16 surrogate code units into single characters as appropriate.
+         */
+        fromString(value: string): Tree;
+    }
+    /**
+     * Interface for a text node.
+     * @remarks
+     * The string is broken up into substrings which are referred to as 'characters'.
+     * Unlike with JavaScript strings, all indexes are by character, not UTF-16 code unit.
+     * This avoids the problem JavaScript where it can split UTF-16 surrogate pairs producing invalid strings,
+     * and avoids the issue where indexing a string and iterating it segment the string differently.
+     * This does NOT mean the characters correspond to user perceived characters (like grapheme clusters try to do):
+     * applications will likely want to include higher level segmentation logic
+     * which might differ between operations like delete
+     * (which often operates on something in between unicode code points and grapheme clusters)
+     * and navigation/selection (which typically uses grapheme clusters).
+     *
+     * @see {@link FormattedTextAsTree.Statics.fromString} for construction.
+     * @see {@link FormattedTextAsTree.(Tree:type)} for schema.
+     * @internal
+     */
+    export interface Members extends TextAsTree.Members {
+        /**
+         * Format to use by default for text inserted with non-formatted APIs.
+         * @remarks
+         * This is not persisted in the tree, and observation of it is not tracked by the tree observation tracking.
+         * @privateRemarks
+         * Opt this into observation tracking.
+         */
+        defaultFormat: CharacterFormat;
+        /**
+         * Gets an iterable over the characters currently in the text.
+         * @remarks
+         * This iterator matches the behavior of {@link (TreeArrayNode:interface)} with respect to edits during iteration.
+         */
+        charactersWithFormatting(): Iterable<StringAtom>;
+        /**
+         * Insert a range of characters into the string based on character index.
+         * @remarks
+         * See {@link (TreeArrayNode:interface).insertAt} for more details on the behavior.
+         * See {@link FormattedTextAsTree.Statics.fromString} for how the `additionalCharacters` string is broken into characters.
+         * @privateRemarks
+         * If we provide ways to customize character boundaries, that could be handled here by taking in an Iterable<string> instead of a string.
+         * Doing this currently would enable insertion of text with different character boundaries than the existing text,
+         * which would violate the currently documented character boundary invariants.
+         *
+         * Another option would be to take an approach like Table,
+         * where the user of the API uses a factory function to generate the schema, and can inject custom logic, like a string character iterator.
+         */
+        insertWithFormattingAt(index: number, additionalCharacters: Iterable<InsertableTypedNode<typeof StringAtom>>): void;
+        /**
+         * Apply formatting to a range of characters based on character index.
+         * @param startIndex - The starting index of the range to format.
+         * @param length - The number of characters to format.
+         * @param format - The formatting to apply to the specified range.
+         */
+        formatRange(startIndex: number, length: number, format: Partial<CharacterFormat>): void;
+    }
+    /**
+     * Schema for a text node.
+     * @remarks
+     * See {@link FormattedTextAsTree.Members} for the API.
+     * See {@link FormattedTextAsTree.Statics} for static APIs on this Schema, including construction.
+     * @internal
+     */
+    export const Tree: Statics & import("../simple-tree/index.js").TreeNodeSchema<"com.fluidframework.text.formatted.Text", import("../simple-tree/index.js").NodeKind, Members & TreeNode & WithType<"com.fluidframework.text.formatted.Text", import("../simple-tree/index.js").NodeKind, unknown>, never, false>;
+    export type Tree = Members & TreeNode & WithType<"com.fluidframework.text.formatted.Text">;
+    export {};
+}
+//# sourceMappingURL=textDomainFormatted.d.ts.map

package/dist/text/textDomainFormatted.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"textDomainFormatted.d.ts","sourceRoot":"","sources":["../../src/text/textDomainFormatted.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAcH,OAAO,KAAK,EACX,mBAAmB,EACnB,QAAQ,EACR,gCAAgC,EAChC,QAAQ,EACR,MAAM,yBAAyB,CAAC;AAGjC,OAAO,EAAwB,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AA4GxE;;;;;;;;GAQG;AACH,yBAAiB,mBAAmB,CAAC;;;;;;;;;;IACpC;;;OAGG;IACH,MAAM,OAAO,eAAgB,SAAQ,oBAMnC;KAAG;;QAOJ;;;;;;;;;;WAUG;;;;;QAVH;;;;;;;;;;WAUG;;;IAfJ;;;OAGG;IACH,MAAM,OAAO,cAAe,SAAQ,mBAalC;KAAG;IAEL;;;OAGG;IACH,MAAM,CAAC,MAAM,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;KAOlB,CAAC;IACH;;;OAGG;IACH,MAAM,MAAM,OAAO,GAAG,gCAAgC,CAAC,OAAO,OAAO,CAAC,MAAM,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE9E;;;;;;;OAOG;IACH,MAAM,OAAO,cAAe,SAAQ,mBAElC;QACD,SAAgB,OAAO,QAAQ;KAC/B;IAED;;;OAGG;IACH,MAAM,CAAC,MAAM,iBAAiB,yDAA4C,CAAC;IAC3E;;;OAGG;IACH,MAAM,MAAM,iBAAiB,GAAG,gCAAgC,CAAC,OAAO,iBAAiB,CAAC,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;IAE3F;;;OAGG;IACH,MAAM,OAAO,UAAW,SAAQ,eAG9B;KAAG;IAEL;;;OAGG;IACH,MAAM,WAAW,OAAO;QACvB;;;WAGG;QACH,UAAU,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,CAAC;KAChC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,MAAM,WAAW,OAAQ,SAAQ,UAAU,CAAC,OAAO;QAClD;;;;;;WAMG;QACH,aAAa,EAAE,eAAe,CAAC;QAE/B;;;;WAIG;QACH,wBAAwB,IAAI,QAAQ,CAAC,UAAU,CAAC,CAAC;QAEjD;;;;;;;;;;;;WAYG;QACH,sBAAsB,CACrB,KAAK,EAAE,MAAM,EACb,oBAAoB,EAAE,QAAQ,CAAC,mBAAmB,CAAC,OAAO,UAAU,CAAC,CAAC,GACpE,IAAI,CAAC;QAER;;;;;WAKG;QACH,WAAW,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,OAAO,CAAC,eAAe,CAAC,GAAG,IAAI,CAAC;KACxF;IAED;;;;;;OAMG;IACH,MAAM,CAAC,MAAM,IAAI,8RAAmD,CAAC;IACrE,MAAM,MAAM,IAAI,GAAG,OAAO,GAAG,QAAQ,GAAG,QAAQ,CAAC,wCAAwC,CAAC,CAAC;;CAC3F"}