@fluidframework/tree 2.41.0-337492 → 2.41.0-338401

package/dist/tableSchema.d.ts

@@ -11,7 +11,7 @@ import { type FieldHasDefault, type ImplicitAllowedTypes, type InsertableTreeNod
  * This namespace should be strictly type-exported by the package.
  * All members should be tagged with `@system`.
  *
- * @system @internal
+ * @system @alpha
  */
 export declare namespace System_TableSchema {
     /**
@@ -20,14 +20,14 @@ export declare namespace System_TableSchema {
      * Longer term, it would be better to simply omit "props" altogether by default.
      * For now, this ensures that the user doesn't have to specify a "props" entry when initializing column/row nodes
      * and ensures that they cannot set anything that might conflict with future evolutions of the schema.
-     * @system @internal
+     * @system @alpha
      */
     type DefaultPropsType = ReturnType<typeof SchemaFactory.optional<[]>>;
     /**
      * A base interface for factory input options which include an schema factory.
      * @remarks This interface should not be referenced directly.
      * @privateRemarks This interface primarily exists to provide a single home for property documentation.
-     * @system @internal
+     * @system @alpha
      */
     interface OptionsWithSchemaFactory<TSchemaFactory extends SchemaFactoryAlpha> {
         /**
@@ -40,7 +40,7 @@ export declare namespace System_TableSchema {
      * A base interface for factory input options which include the table cell schema.
      * @remarks This interface should not be referenced directly.
      * @privateRemarks This interface primarily exists to provide a single home for property documentation.
-     * @system @internal
+     * @system @alpha
      */
     interface OptionsWithCellSchema<TCellSchema extends ImplicitAllowedTypes> {
         /**
@@ -51,14 +51,14 @@ export declare namespace System_TableSchema {
     /**
      * Base options for creating table cow schema.
      * @remarks Includes parameters common to all column factory overloads.
-     * @system @internal
+     * @system @alpha
      */
-    type CreateColumnOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha> = OptionsWithSchemaFactory<TSchemaFactory>;
+    type CreateColumnOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha, TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes> = OptionsWithSchemaFactory<TSchemaFactory> & OptionsWithCellSchema<TCell>;
     /**
      * Factory for creating column schema.
-     * @system @internal
+     * @system @alpha
      */
-    function createColumnSchema<const TInputScope extends string | undefined, const TPropsSchema extends ImplicitAnnotatedFieldSchema>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, propsSchema: TPropsSchema): TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Column">, NodeKind.Object, TreeNode & TableSchema.Column<TPropsSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Column">, NodeKind, unknown>, object & {
+    function createColumnSchema<const TInputScope extends string | undefined, const TCellSchema extends ImplicitAllowedTypes, const TPropsSchema extends ImplicitAnnotatedFieldSchema>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, cellSchema: TCellSchema, propsSchema: TPropsSchema): TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Column">, NodeKind.Object, TreeNode & TableSchema.Column<TCellSchema, TPropsSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Column">, NodeKind, unknown>, object & {
         readonly id?: string | undefined;
     } & (FieldHasDefault<UnannotateImplicitFieldSchema<TPropsSchema>> extends true ? {
         /**
@@ -78,18 +78,18 @@ export declare namespace System_TableSchema {
     }>;
     /**
      * Base column schema type.
-     * @sealed @system @internal
+     * @sealed @system @alpha
      */
-    type ColumnSchemaBase<TScope extends string | undefined = string | undefined, TPropsSchema extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> = ReturnType<typeof createColumnSchema<TScope, TPropsSchema>>;
+    type ColumnSchemaBase<TScope extends string | undefined = string | undefined, TCellSchema extends ImplicitAllowedTypes = ImplicitAllowedTypes, TPropsSchema extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> = ReturnType<typeof createColumnSchema<TScope, TCellSchema, TPropsSchema>>;
     /**
      * Base options for creating table row schema.
      * @remarks Includes parameters common to all row factory overloads.
-     * @system @internal
+     * @system @alpha
      */
     type CreateRowOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha, TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes> = OptionsWithSchemaFactory<TSchemaFactory> & OptionsWithCellSchema<TCell>;
     /**
      * Factory for creating row schema.
-     * @sealed @internal
+     * @sealed @alpha
      */
     function createRowSchema<const TInputScope extends string | undefined, const TCellSchema extends ImplicitAllowedTypes, const TPropsSchema extends ImplicitAnnotatedFieldSchema>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, cellSchema: TCellSchema, propsSchema: TPropsSchema): TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row">, NodeKind.Object, TreeNode & TableSchema.Row<TCellSchema, TPropsSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row">, NodeKind, unknown>, object & {
         readonly id?: string | undefined;
@@ -115,37 +115,61 @@ export declare namespace System_TableSchema {
     }>;
     /**
      * Base row schema type.
-     * @sealed @system @internal
+     * @sealed @system @alpha
      */
     type RowSchemaBase<TScope extends string | undefined = string | undefined, TCellSchema extends ImplicitAllowedTypes = ImplicitAllowedTypes, TPropsSchema extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> = ReturnType<typeof createRowSchema<TScope, TCellSchema, TPropsSchema>>;
     /**
      * Base options for creating table schema.
      * @remarks Includes parameters common to all table factory overloads.
-     * @system @internal
+     * @system @alpha
      */
     type TableFactoryOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha, TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes> = OptionsWithSchemaFactory<TSchemaFactory> & OptionsWithCellSchema<TCell>;
     /**
      * Factory for creating table schema.
-     * @system @internal
+     * @system @alpha
      */
-    function createTableSchema<const TInputScope extends string | undefined, const TCellSchema extends ImplicitAllowedTypes, const TColumnSchema extends ColumnSchemaBase<TInputScope>, const TRowSchema extends RowSchemaBase<TInputScope, TCellSchema>>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, _cellSchema: TCellSchema, columnSchema: TColumnSchema, rowSchema: TRowSchema): TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table">, NodeKind.Object, TreeNode & TableSchema.Table<TCellSchema, TColumnSchema, TRowSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table">, NodeKind, unknown>, object & {
-        readonly rows: (import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>)> | undefined) & import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>)>;
-        readonly columns: (import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>)> | undefined) & import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>)>;
-    }, true, {
+    function createTableSchema<const TInputScope extends string | undefined, const TCellSchema extends ImplicitAllowedTypes, const TColumnSchema extends ColumnSchemaBase<TInputScope, TCellSchema>, const TRowSchema extends RowSchemaBase<TInputScope, TCellSchema>>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, _cellSchema: TCellSchema, columnSchema: TColumnSchema, rowSchema: TRowSchema): import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table">, NodeKind.Object, true, {
         readonly rows: TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, true, TRowSchema, undefined>;
         readonly columns: TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, true, TColumnSchema, undefined>;
-    }>;
+    }, object & {
+        readonly rows: (import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>)> | undefined) & import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>)>;
+        readonly columns: (import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>)> | undefined) & import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>)>;
+    }, unknown> & (new (data: InternalTreeNode | (object & {
+        readonly rows: (import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>)> | undefined) & import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>)>;
+        readonly columns: (import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>)> | undefined) & import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>)>;
+    })) => TreeNode & TableSchema.Table<TInputScope, TCellSchema, TColumnSchema, TRowSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table">, NodeKind, unknown>) & {
+        /**
+         * Create an empty table.
+         */
+        empty<TThis extends new (data: {
+            readonly rows: (import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>)> | undefined) & import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, true, TRowSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>> | undefined) => TreeArrayNode<TRowSchema, [TRowSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRowSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRowSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, unknown>)>;
+            readonly columns: (import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>)> | undefined) & import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, true, TColumnSchema, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>, unknown> & (new (data?: InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>> | undefined) => TreeArrayNode<TColumnSchema, [TColumnSchema] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumnSchema> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumnSchema] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema> : never, import("./simple-tree/arrayNode.js").ReadonlyArrayNode<TreeNode | import("./simple-tree/schemaTypes.js").TreeLeafValue>> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, unknown>)>;
+        }) => TreeNode & TableSchema.Table<TInputScope, TCellSchema, TColumnSchema, TRowSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table">, NodeKind, unknown>>(this: TThis): InstanceType<TThis>;
+    };
     /**
      * Base row schema type.
-     * @sealed @system @internal
+     * @sealed @system @alpha
      */
-    type TableSchemaBase<TScope extends string | undefined, TCell extends ImplicitAllowedTypes, TColumn extends ColumnSchemaBase<TScope>, TRow extends RowSchemaBase<TScope, TCell>> = ReturnType<typeof createTableSchema<TScope, TCell, TColumn, TRow>>;
+    type TableSchemaBase<TScope extends string | undefined, TCell extends ImplicitAllowedTypes, TColumn extends ColumnSchemaBase<TScope, TCell>, TRow extends RowSchemaBase<TScope, TCell>> = ReturnType<typeof createTableSchema<TScope, TCell, TColumn, TRow>>;
 }
 /**
  * Contains types and factories for creating schema to represent dynamic tabular data.
  *
  * @remarks
  *
+ * WARNING: These APIs are in preview and are subject to change.
+ * Until these APIs have stabilized, it is not recommended to use them in production code.
+ * There may be breaking changes to these APIs and their underlying data format.
+ * Using these APIs in production code may result in data loss or corruption.
+ *
+ * The primary APIs for create tabular data schema are:
+ *
+ * - {@link TableSchema.(table:1)}
+ *
+ * - {@link TableSchema.(column:1)}
+ *
+ * - {@link TableSchema.(row:1)}
+ *
  * Tables created using these APIs are...
  *
  * - sparse, meaning that cells may be omitted, and new rows are empty by default.
@@ -159,84 +183,121 @@ export declare namespace System_TableSchema {
  * Column and Row schema created using these APIs are extensible via the `props` field.
  * This allows association of additional properties with column and row nodes.
  *
- * Note: for now it is possible for table cells to become "orphaned".
+ * Cells in the table may become "orphaned."
  * That is, it is possible to enter a state where one or more rows contain cells with no corresponding column.
- * To help avoid this situation, you can manually remove corresponding cells when removing columns.
+ * To reduce the likelihood of this, you can manually remove corresponding cells when removing columns.
  * Either way, it is possible to enter such a state via the merging of edits.
  * For example: one client might add a row while another concurrently removes a column, orphaning the cell where the column and row intersected.
  *
- * @example Using default Column and Row schema
+ * @example Defining a Table schema
  *
  * ```typescript
- * class Cell extends schemaFactory.object("TableCell", {
- * 	value: schemaFactory.string,
- * }) {}
- *
- * class Table extends TableSchema.table({
+ * class MyTable extends TableSchema.table({
  * 	schemaFactory,
- * 	cell: Cell,
+ * 	cell: schemaFactory.string,
  * }) {}
  *
- * const table = new Table({
+ * const table = new MyTable({
  * 	columns: [{ id: "column-0" }],
- * 	rows: [{ id: "row-0", cells: {} }],
+ * 	rows: [{ id: "row-0", cells: { "column-0": "Hello world!" } }],
  * });
  * ```
  *
  * @example Customizing Column and Row schema
  *
  * ```typescript
- * class Cell extends schemaFactory.object("TableCell", {
- * 	value: schemaFactory.string,
- * }) {}
- *
- * class ColumnProps extends schemaFactory.object("TableColumnProps", {
- * 	// Column label to display.
- * 	label: schemaFactory.string,
- * 	// The type of data represented by the cells. Default: string.
- * 	dataType: schemaFactory.optional(schemaFactory.string),
- * }) {}
+ * const Cell = schemaFactory.string;
  *
- * class Column extends TableSchema.column({
+ * class MyColumn extends TableSchema.column({
  * 	schemaFactory,
- * 	props: ColumnProps,
+ * 	cell: Cell,
+ * 	props: schemaFactory.object("TableColumnProps", {
+ * 		label: schemaFactory.string,
+ * 	}),
  * }) {}
  *
- * class Row extends TableSchema.row({
+ * class MyRow extends TableSchema.row({
  * 	schemaFactory,
  * 	cell: Cell,
  * }) {}
  *
- * class Table extends TableSchema.table({
+ * class MyTable extends TableSchema.table({
  * 	schemaFactory,
  * 	cell: Cell,
- * 	column: Column,
- * 	row: Row,
+ * 	column: MyColumn,
+ * 	row: MyRow,
  * }) {}
  *
- * const table = new Table({
+ * const table = new MyTable({
  * 	columns: [
- * 		new Column({ props: { label: "Entry", dataType: "string" } }),
- * 		new Column({ props: { label: "Date", dataType: "date" } }),
- * 		new Column({ props: { label: "Amount", dataType: "number" } }),
+ * 		new MyColumn({ props: { label: "Entry" } }),
+ * 		new MyColumn({ props: { label: "Date" } }),
+ * 		new MyColumn({ props: { label: "Amount" } }),
  * 	],
  * 	rows: [],
  * });
  * ```
  *
+ * @example Listening for changes in the table
+ *
+ * ```typescript
+ * // Listen for any changes to the table and its children.
+ * // The "treeChanged" event will fire when the associated node or any of its descendants change.
+ * Tree.on(table, "treeChanged", () => {
+ * 	// Respond to the change.
+ * });
+ * ```
+ *
+ * @example Listening for changes to the rows list only
+ *
+ * ```typescript
+ * // Listen for any changes to the list of rows.
+ * // The "nodeChanged" event will fire only when the specified node itself changes (i.e., its own properties change).
+ * // In this case, the event will fire when a row is added or removed, or the order of the list is changed.
+ * // But it won't fire when a row's properties change, or when the row's cells change, etc.
+ * Tree.on(table.rows, "nodeChanged", () => {
+ * 	// Respond to the change.
+ * });
+ * ```
+ *
+ * @example Removing column and cells in a transaction
+ *
+ * When removing a column, if you wish to ensure that all of its corresponding cells are also removed (and not
+ * orphaned), you can remove the column and all of the relevant cells in a transaction.
+ * Note that there are performance implications to this.
+ *
+ * ```typescript
+ * // Remove column1 and all of its cells.
+ * // The "transaction" method will ensure that all changes are applied atomically.
+ * Tree.runTransaction(table, () => {
+ * 	// Remove column1.
+ * 	table.removeColumn(column1);
+ *
+ * 	// Remove the cell at column1 for each row.
+ * 	for (const row of table.rows) {
+ * 		table.removeCell({
+ * 			column: column1,
+ * 			row,
+ * 		});
+ * 	}
+ * });
+ * ```
+ *
  * @privateRemarks
  * The above examples are backed by tests in `tableSchema.spec.ts`.
  * Those tests and these examples should be kept in-sync to ensure that the examples are correct.
  *
- * @internal
+ * @alpha
  */
 export declare namespace TableSchema {
     /**
      * A column in a table.
      * @remarks Implemented by the schema class returned from {@link TableSchema.(column:2)}.
-     * @sealed @internal
+     * @typeParam TCell - The type of the cells in the {@link TableSchema.Table}.
+     * @typeParam TProps - Additional properties to associate with the column.
+     * @sealed @alpha
      */
-    interface Column<TProps extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> {
+    interface Column<TCell extends ImplicitAllowedTypes, TProps extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> {
         /**
          * The unique identifier of the column.
          * @remarks Uniquely identifies the node within the entire tree, not just the table.
@@ -251,28 +312,43 @@ export declare namespace TableSchema {
          */
         get props(): TreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TProps>>;
         set props(value: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TProps>>);
+        /**
+         * Gets all of the populated cells in the column, keyed by their associated row IDs.
+         * @throws Throws an error if the column is not in a table.
+         */
+        getCells(): readonly {
+            rowId: string;
+            cell: TreeNodeFromImplicitAllowedTypes<TCell>;
+        }[];
     }
     /**
      * Factory for creating new table column schema.
-     * @internal
+     * @typeParam TScope - The {@link SchemaFactory.scope | schema factory scope}.
+     * @typeParam TCell - The type of the cells in the {@link TableSchema.Table}.
+     * @alpha
      */
-    function column<const TScope extends string | undefined>(params: System_TableSchema.CreateColumnOptionsBase<SchemaFactoryAlpha<TScope>>): System_TableSchema.ColumnSchemaBase<TScope, System_TableSchema.DefaultPropsType>;
+    function column<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes>(params: System_TableSchema.CreateColumnOptionsBase<SchemaFactoryAlpha<TScope>, TCell>): System_TableSchema.ColumnSchemaBase<TScope, TCell, System_TableSchema.DefaultPropsType>;
     /**
      * Factory for creating new table column schema.
-     * @internal
+     * @typeParam TScope - The {@link SchemaFactory.scope | schema factory scope}.
+     * @typeParam TCell - The type of the cells in the {@link TableSchema.Table}.
+     * @typeParam TProps - Additional properties to associate with the column.
+     * @alpha
      */
-    function column<const TScope extends string | undefined, const TProps extends ImplicitAnnotatedFieldSchema>(params: System_TableSchema.CreateColumnOptionsBase<SchemaFactoryAlpha<TScope>> & {
+    function column<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TProps extends ImplicitAnnotatedFieldSchema>(params: System_TableSchema.CreateColumnOptionsBase<SchemaFactoryAlpha<TScope>, TCell> & {
         /**
          * Optional column properties.
          */
         readonly props: TProps;
-    }): System_TableSchema.ColumnSchemaBase<TScope, TProps>;
+    }): System_TableSchema.ColumnSchemaBase<TScope, TCell, TProps>;
     /**
      * A row in a table.
-     * @remarks Implemented by the schema class returned from {@link TableSchema.(createRow:2)}.
-     * @sealed @internal
+     * @remarks Implemented by the schema class returned from {@link TableSchema.(row:2)}.
+     * @typeParam TCell - The type of the cells in the {@link TableSchema.Table}.
+     * @typeParam TProps - Additional properties to associate with the row.
+     * @sealed @alpha
      */
-    interface Row<TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes, TProps extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> {
+    interface Row<TCell extends ImplicitAllowedTypes, TProps extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> {
         /**
          * The unique identifier of the row.
          * @remarks Uniquely identifies the node within the entire tree, not just the table.
@@ -283,18 +359,25 @@ export declare namespace TableSchema {
          * @returns The cell if it exists, otherwise undefined.
          * @privateRemarks TODO: throw if the column does not belong to the same table as the row.
          */
-        getCell(column: Column): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
+        getCell(column: Column<TCell>): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
         /**
          * Gets the cell in the specified column, denoted by column ID.
          * @returns The cell if it exists, otherwise undefined.
          */
         getCell(columnId: string): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
+        /**
+         * Gets all of the populated cells in the row, keyed by their associated column IDs.
+         */
+        getCells(): readonly {
+            columnId: string;
+            cell: TreeNodeFromImplicitAllowedTypes<TCell>;
+        }[];
         /**
          * Sets the cell in the specified column.
          * @remarks To remove a cell, call {@link TableSchema.Row.(removeCell:1)} instead.
          * @privateRemarks TODO: Throw an error if the column does not exist in the table.
          */
-        setCell(column: Column, value: InsertableTreeNodeFromImplicitAllowedTypes<TCell>): void;
+        setCell(column: Column<TCell>, value: InsertableTreeNodeFromImplicitAllowedTypes<TCell>): void;
         /**
          * Sets the cell in the specified column, denoted by column ID.
          * @remarks To remove a cell, call {@link TableSchema.Row.(removeCell:2)} instead.
@@ -305,7 +388,7 @@ export declare namespace TableSchema {
          * @returns The cell if it exists, otherwise undefined.
          * @privateRemarks TODO: Throw if the column does not belong to the same table as the row.
          */
-        removeCell(column: Column): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
+        removeCell(column: Column<TCell>): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
         /**
          * Removes the cell in the specified column, denoted by column ID.
          * @returns The cell if it exists, otherwise undefined.
@@ -323,12 +406,17 @@ export declare namespace TableSchema {
     }
     /**
      * Factory for creating new table column schema.
-     * @internal
+     * @typeParam TScope - The {@link SchemaFactory.scope | schema factory scope}.
+     * @typeParam TCell - The type of the cells in the {@link TableSchema.Table}.
+     * @alpha
      */
     function row<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes>(params: System_TableSchema.CreateRowOptionsBase<SchemaFactoryAlpha<TScope>, TCell>): System_TableSchema.RowSchemaBase<TScope, TCell, System_TableSchema.DefaultPropsType>;
     /**
      * Factory for creating new table row schema.
-     * @internal
+     * @typeParam TScope - The {@link SchemaFactory.scope | schema factory scope}.
+     * @typeParam TCell - The type of the cells in the {@link TableSchema.Table}.
+     * @typeParam TProps - Additional properties to associate with the row.
+     * @alpha
      */
     function row<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TProps extends ImplicitAnnotatedFieldSchema>(params: System_TableSchema.CreateRowOptionsBase<SchemaFactoryAlpha<TScope>, TCell> & {
         /**
@@ -338,7 +426,7 @@ export declare namespace TableSchema {
     }): System_TableSchema.RowSchemaBase<TScope, TCell, TProps>;
     /**
      * A key to uniquely identify a cell within a table.
-     * @internal
+     * @alpha
      */
     interface CellKey<TColumn extends ImplicitAllowedTypes, TRow extends ImplicitAllowedTypes> {
         /**
@@ -352,7 +440,7 @@ export declare namespace TableSchema {
     }
     /**
      * {@link TableSchema.Table.insertColumn} parameters.
-     * @internal
+     * @alpha
      */
     interface InsertColumnParameters<TColumn extends ImplicitAllowedTypes> {
         /**
@@ -367,7 +455,7 @@ export declare namespace TableSchema {
     }
     /**
      * {@link TableSchema.Table.insertColumns} parameters.
-     * @internal
+     * @alpha
      */
     interface InsertColumnsParameters<TColumn extends ImplicitAllowedTypes> {
         /**
@@ -382,7 +470,7 @@ export declare namespace TableSchema {
     }
     /**
      * {@link TableSchema.Table.insertRow} parameters.
-     * @internal
+     * @alpha
      */
     interface InsertRowParameters<TRow extends ImplicitAllowedTypes> {
         /**
@@ -397,7 +485,7 @@ export declare namespace TableSchema {
     }
     /**
      * {@link TableSchema.Table.insertRows} parameters.
-     * @internal
+     * @alpha
      */
     interface InsertRowsParameters<TRow extends ImplicitAllowedTypes> {
         /**
@@ -412,7 +500,7 @@ export declare namespace TableSchema {
     }
     /**
      * {@link TableSchema.Table.setCell} parameters.
-     * @internal
+     * @alpha
      */
     interface SetCellParameters<TCell extends ImplicitAllowedTypes, TColumn extends ImplicitAllowedTypes, TRow extends ImplicitAllowedTypes> {
         /**
@@ -426,9 +514,13 @@ export declare namespace TableSchema {
     }
     /**
      * A table.
-     * @sealed @internal
+     * @typeParam TScope - The {@link SchemaFactory.scope | schema factory scope}.
+     * @typeParam TCell - The type of the cells in the table.
+     * @typeParam TColumn - The type of the columns in the table.
+     * @typeParam TRow - The type of the rows in the table.
+     * @sealed @alpha
      */
-    interface Table<TCell extends ImplicitAllowedTypes, TColumn extends ImplicitAllowedTypes, TRow extends ImplicitAllowedTypes> {
+    interface Table<TScope extends string | undefined, TCell extends ImplicitAllowedTypes, TColumn extends System_TableSchema.ColumnSchemaBase<TScope, TCell>, TRow extends System_TableSchema.RowSchemaBase<TScope, TCell>> {
         /**
          * The table's columns.
          */
@@ -453,27 +545,17 @@ export declare namespace TableSchema {
         /**
          * Inserts a column into the table.
          *
-         * @throws
-         * Throws an error in the following cases:
-         *
-         * - The column, or a column with the same ID is already in the tree.
+         * @throws Throws an error if the specified index is out of range.
          *
-         * - The specified index is out of range.
-         *
-         * No column is inserted in these cases.
+         * No column is inserted in this case.
          */
         insertColumn(params: InsertColumnParameters<TColumn>): TreeNodeFromImplicitAllowedTypes<TColumn>;
         /**
          * Inserts 0 or more columns into the table.
          *
-         * @throws
-         * Throws an error in the following cases:
-         *
-         * - At least one column, or a column with the same ID is already in the tree.
-         *
-         * - The specified index is out of range.
+         * @throws Throws an error if the specified index is out of range.
          *
-         * No columns are inserted in these cases.
+         * No columns are inserted in this case.
          */
         insertColumns(params: InsertColumnsParameters<TColumn>): TreeNodeFromImplicitAllowedTypes<TColumn>[];
         /**
@@ -482,8 +564,6 @@ export declare namespace TableSchema {
          * @throws
          * Throws an error in the following cases:
          *
-         * - The row, or a row with the same ID is already in the tree.
-         *
          * - The row contains cells, but the table does not contain matching columns for one or more of those cells.
          *
          * - The specified index is out of range.
@@ -497,8 +577,6 @@ export declare namespace TableSchema {
          * @throws
          * Throws an error in the following cases:
          *
-         * - At least one row, or a row with the same ID is already in the tree.
-         *
          * - The row contains cells, but the table does not contain matching columns for one or more of those cells.
          *
          * - The specified index is out of range.
@@ -585,22 +663,41 @@ export declare namespace TableSchema {
         removeCell(key: CellKey<TColumn, TRow>): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
     }
     /**
-     * Factory for creating new table schema without specifying row or column schema.
-     * @internal
+     * Factory for creating new table schema.
+     * @typeParam TScope - The {@link SchemaFactory.scope | schema factory scope}.
+     * @typeParam TCell - The type of the cells in the table.
+     * @alpha
      */
-    function table<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes>(params: System_TableSchema.TableFactoryOptionsBase<SchemaFactoryAlpha<TScope>, TCell>): System_TableSchema.TableSchemaBase<TScope, TCell, System_TableSchema.ColumnSchemaBase<TScope, System_TableSchema.DefaultPropsType>, System_TableSchema.RowSchemaBase<TScope, TCell, System_TableSchema.DefaultPropsType>>;
+    function table<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes>(params: System_TableSchema.TableFactoryOptionsBase<SchemaFactoryAlpha<TScope>, TCell>): System_TableSchema.TableSchemaBase<TScope, TCell, System_TableSchema.ColumnSchemaBase<TScope, TCell, System_TableSchema.DefaultPropsType>, System_TableSchema.RowSchemaBase<TScope, TCell, System_TableSchema.DefaultPropsType>>;
     /**
-     * Factory for creating new table schema without specifying row schema.
-     * @internal
+     * Factory for creating new table schema with custom column schema.
+     * @typeParam TScope - The {@link SchemaFactory.scope | schema factory scope}.
+     * @typeParam TCell - The type of the cells in the table.
+     * @typeParam TColumn - The type of the columns in the table.
+     * @alpha
      */
-    function table<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TColumn extends System_TableSchema.ColumnSchemaBase<TScope>>(params: System_TableSchema.TableFactoryOptionsBase<SchemaFactoryAlpha<TScope>, TCell> & {
+    function table<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TColumn extends System_TableSchema.ColumnSchemaBase<TScope, TCell>>(params: System_TableSchema.TableFactoryOptionsBase<SchemaFactoryAlpha<TScope>, TCell> & {
         readonly column: TColumn;
     }): System_TableSchema.TableSchemaBase<TScope, TCell, TColumn, System_TableSchema.RowSchemaBase<TScope, TCell, System_TableSchema.DefaultPropsType>>;
     /**
-     * Factory for creating new table schema.
-     * @internal
+     * Factory for creating new table schema with custom row schema.
+     * @typeParam TScope - The {@link SchemaFactory.scope | schema factory scope}.
+     * @typeParam TCell - The type of the cells in the table.
+     * @typeParam TRow - The type of the rows in the table.
+     * @alpha
+     */
+    function table<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TRow extends System_TableSchema.RowSchemaBase<TScope, TCell>>(params: System_TableSchema.TableFactoryOptionsBase<SchemaFactoryAlpha<TScope>, TCell> & {
+        readonly row: TRow;
+    }): System_TableSchema.TableSchemaBase<TScope, TCell, System_TableSchema.ColumnSchemaBase<TScope, TCell, System_TableSchema.DefaultPropsType>, TRow>;
+    /**
+     * Factory for creating new table schema with custom column and row schema.
+     * @typeParam TScope - The {@link SchemaFactory.scope | schema factory scope}.
+     * @typeParam TCell - The type of the cells in the table.
+     * @typeParam TColumn - The type of the columns in the table.
+     * @typeParam TRow - The type of the rows in the table.
+     * @alpha
      */
-    function table<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TColumn extends System_TableSchema.ColumnSchemaBase<TScope>, const TRow extends System_TableSchema.RowSchemaBase<TScope, TCell>>(params: System_TableSchema.TableFactoryOptionsBase<SchemaFactoryAlpha<TScope>, TCell> & {
+    function table<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TColumn extends System_TableSchema.ColumnSchemaBase<TScope, TCell>, const TRow extends System_TableSchema.RowSchemaBase<TScope, TCell>>(params: System_TableSchema.TableFactoryOptionsBase<SchemaFactoryAlpha<TScope>, TCell> & {
         readonly column: TColumn;
         readonly row: TRow;
     }): System_TableSchema.TableSchemaBase<TScope, TCell, TColumn, TRow>;