@fluidframework/tree 2.33.2 → 2.40.0

package/lib/tableSchema.d.ts

@@ -2,57 +2,278 @@
  * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
  * Licensed under the MIT License.
  */
-import { type ImplicitAllowedTypes, type InsertableTreeNodeFromImplicitAllowedTypes, type NodeKind, type SchemaFactoryAlpha, type ScopedSchemaName, TreeArrayNode, type TreeNode, type TreeNodeFromImplicitAllowedTypes, type TreeNodeSchemaClass, type WithType } from "./simple-tree/index.js";
+import { type FieldHasDefault, type ImplicitAllowedTypes, type InsertableTreeNodeFromImplicitAllowedTypes, type NodeKind, type SchemaFactoryAlpha, type ScopedSchemaName, TreeArrayNode, type TreeNode, type TreeNodeFromImplicitAllowedTypes, type TreeNodeSchemaClass, type WithType, type TreeFieldFromImplicitField, type InsertableTreeFieldFromImplicitField, type InternalTreeNode, SchemaFactory, type ImplicitAnnotatedFieldSchema, type UnannotateImplicitFieldSchema } from "./simple-tree/index.js";
+/**
+ * Not intended for use outside of this package.
+ *
+ * @privateRemarks
+ * This namespace is a collection of internal system types relate to {@link TableSchema}.
+ * This namespace should be strictly type-exported by the package.
+ * All members should be tagged with `@system`.
+ *
+ * @system @internal
+ */
+export declare namespace System_TableSchema {
+    /**
+     * Default type used for column and row "props" fields.
+     * @privateRemarks
+     * 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
+     */
+    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
+     */
+    interface OptionsWithSchemaFactory<TSchemaFactory extends SchemaFactoryAlpha> {
+        /**
+         * Schema factory with which the Column schema will be associated.
+         * @remarks Can be used to associate the resulting schema with an existing {@link SchemaFactory.scope|scope}.
+         */
+        readonly schemaFactory: TSchemaFactory;
+    }
+    /**
+     * 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
+     */
+    interface OptionsWithCellSchema<TCellSchema extends ImplicitAllowedTypes> {
+        /**
+         * Schema for the table's cells.
+         */
+        readonly cell: TCellSchema;
+    }
+    /**
+     * Base options for creating table cow schema.
+     * @remarks Includes parameters common to all column factory overloads.
+     * @system @internal
+     */
+    type CreateColumnOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha> = OptionsWithSchemaFactory<TSchemaFactory>;
+    /**
+     * Factory for creating new table column schema.
+     * @system @internal
+     */
+    function createColumnInternal<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 & {
+        readonly id?: string | undefined;
+    } & (FieldHasDefault<UnannotateImplicitFieldSchema<TPropsSchema>> extends true ? {
+        /**
+         * The column's properties.
+         * @remarks This is a user-defined schema that can be used to store additional information about the column.
+         */
+        props?: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TPropsSchema>> | undefined;
+    } : {
+        /**
+         * The column's properties.
+         * @remarks This is a user-defined schema that can be used to store additional information about the column.
+         */
+        props: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TPropsSchema>>;
+    }), true, {
+        readonly props: TPropsSchema;
+        readonly id: import("./simple-tree/schemaTypes.js").FieldSchema<import("./simple-tree/schemaTypes.js").FieldKind.Identifier, import("./simple-tree/leafNodeSchema.js").LeafSchema<"string", string>, unknown>;
+    }>;
+    /**
+     * Base column schema type.
+     * @sealed @system @internal
+     */
+    type ColumnSchemaBase<TScope extends string | undefined = string | undefined, TPropsSchema extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> = ReturnType<typeof createColumnInternal<TScope, TPropsSchema>>;
+    /**
+     * Base options for creating table row schema.
+     * @remarks Includes parameters common to all row factory overloads.
+     * @system @internal
+     */
+    type CreateRowOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha, TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes> = OptionsWithSchemaFactory<TSchemaFactory> & OptionsWithCellSchema<TCell>;
+    /**
+     * Factory for creating new table row schema.
+     *
+     * @sealed @internal
+     */
+    function createRowInternal<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;
+        readonly cells: (import("./simple-tree/schemaTypes.js").InsertableTypedNode<TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, import("./simple-tree/mapNode.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>, import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema>, true, TCellSchema, undefined>, import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, true, TCellSchema, import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema>, unknown> & (new (data?: InternalTreeNode | import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema> | undefined) => import("./simple-tree/mapNode.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>)> | undefined) & import("./simple-tree/schemaTypes.js").InsertableTypedNode<TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, import("./simple-tree/mapNode.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>, import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema>, true, TCellSchema, undefined>, import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, true, TCellSchema, import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema>, unknown> & (new (data?: InternalTreeNode | import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema> | undefined) => import("./simple-tree/mapNode.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>)>;
+    } & (FieldHasDefault<UnannotateImplicitFieldSchema<TPropsSchema>> extends true ? {
+        /**
+         * The row's properties.
+         * @remarks This is a user-defined schema that can be used to store additional information
+         * about the row.
+         */
+        props?: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TPropsSchema>> | undefined;
+    } : {
+        /**
+         * The row's properties.
+         * @remarks This is a user-defined schema that can be used to store additional information
+         * about the row.
+         */
+        props: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TPropsSchema>>;
+    }), true, {
+        readonly props: TPropsSchema;
+        readonly id: import("./simple-tree/schemaTypes.js").FieldSchema<import("./simple-tree/schemaTypes.js").FieldKind.Identifier, import("./simple-tree/leafNodeSchema.js").LeafSchema<"string", string>, unknown>;
+        readonly cells: import("./simple-tree/schemaTypes.js").FieldSchema<import("./simple-tree/schemaTypes.js").FieldKind.Required, TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, import("./simple-tree/mapNode.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>, import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema>, true, TCellSchema, undefined>, unknown>;
+    }>;
+    /**
+     * Base row schema type.
+     * @sealed @system @internal
+     */
+    type RowSchemaBase<TScope extends string | undefined = string | undefined, TCellSchema extends ImplicitAllowedTypes = ImplicitAllowedTypes, TPropsSchema extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> = ReturnType<typeof createRowInternal<TScope, TCellSchema, TPropsSchema>>;
+    /**
+     * Base options for creating table schema.
+     * @remarks Includes parameters common to all table factory overloads.
+     * @system @internal
+     */
+    type TableFactoryOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha, TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes> = OptionsWithSchemaFactory<TSchemaFactory> & OptionsWithCellSchema<TCell>;
+    /**
+     * Factory for creating new table schema.
+     * @system @internal
+     */
+    function createTableInternal<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, {
+        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>;
+    }>;
+    /**
+     * Base row schema type.
+     * @sealed @system @internal
+     */
+    type TableSchemaBase<TScope extends string | undefined, TCell extends ImplicitAllowedTypes, TColumn extends ColumnSchemaBase<TScope>, TRow extends RowSchemaBase<TScope, TCell>> = ReturnType<typeof createTableInternal<TScope, TCell, TColumn, TRow>>;
+}
 /**
  * Contains types and factories for creating schema to represent dynamic tabular data.
- * @privateRemarks TODO: document in more detail and add `@example`s.
+ *
+ * @remarks
+ *
+ * Tables created using these APIs are...
+ *
+ * - sparse, meaning that cells may be omitted, and new rows are empty by default.
+ *
+ * - dynamic, meaning that their structure can be modified at runtime.
+ * Columns and rows can be inserted, removed, modified, and reordered.
+ * Cells can be inserted, removed, and modified.
+ *
+ * - row-major, meaning that operating on rows (including inserts, removal, moves, and traversal) is more efficient than operating on columns.
+ *
+ * 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".
+ * 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.
+ * 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
+ *
+ * ```typescript
+ * class Cell extends schemaFactory.object("TableCell", {
+ * 	value: schemaFactory.string,
+ * }) {}
+ *
+ * class Table extends TableSchema.createTable({
+ * 	schemaFactory,
+ * 	cell: Cell,
+ * }) {}
+ *
+ * const table = new Table({
+ * 	columns: [{ id: "column-0" }],
+ * 	rows: [{ id: "row-0", cells: {} }],
+ * });
+ * ```
+ *
+ * @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),
+ * }) {}
+ *
+ * class Column extends TableSchema.createColumn({
+ * 	schemaFactory,
+ * 	props: ColumnProps,
+ * }) {}
+ *
+ * class Row extends TableSchema.createRow({
+ * 	schemaFactory,
+ * 	cell: Cell,
+ * }) {}
+ *
+ * class Table extends TableSchema.createTable({
+ * 	schemaFactory,
+ * 	cell: Cell,
+ * 	column: Column,
+ * 	row: Row,
+ * }) {}
+ *
+ * const table = new Table({
+ * 	columns: [
+ * 		new Column({ props: { label: "Entry", dataType: "string" } }),
+ * 		new Column({ props: { label: "Date", dataType: "date" } }),
+ * 		new Column({ props: { label: "Amount", dataType: "number" } }),
+ * 	],
+ * 	rows: [],
+ * });
+ * ```
+ *
+ * @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
  */
 export declare namespace TableSchema {
     /**
      * A column in a table.
-     * @remarks Implemented by the schema class returned from {@link TableSchema.createColumn}.
+     * @remarks Implemented by the schema class returned from {@link TableSchema.(createColumn:2)}.
      * @sealed @internal
      */
-    interface IColumn<TPropsSchema extends ImplicitAllowedTypes = ImplicitAllowedTypes> {
+    interface Column<TProps extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> {
         /**
          * The unique identifier of the column.
          * @remarks Uniquely identifies the node within the entire tree, not just the table.
          */
         readonly id: string;
         /**
-         * User-provided column properties.
+         * The column's properties.
+         * @remarks This is a user-defined schema that can be used to store additional information about the column.
+         * @privateRemarks
+         * Note: these docs are duplicated on the inline type definitions in {@link createColumn}.
+         * If you update the docs here, please also update the inline type definitions.
          */
-        get props(): TreeNodeFromImplicitAllowedTypes<TPropsSchema>;
-        set props(value: InsertableTreeNodeFromImplicitAllowedTypes<TPropsSchema>);
+        get props(): TreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TProps>>;
+        set props(value: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TProps>>);
     }
     /**
      * Factory for creating new table column schema.
-     * @privateRemarks
-     * TODO:
-     * - Add overloads to make propsSchema optional.
-     * - Take field schema rather than node schema for `propsSchema`, in particular to allow making
-     * the additional properties optional.
      * @internal
      */
-    function createColumn<const TInputScope extends string | undefined, const TPropsSchema extends ImplicitAllowedTypes>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, propsSchema: TPropsSchema): TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Column">, NodeKind.Object, TreeNode & IColumn<TPropsSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Column">, NodeKind, unknown>, object & {
-        readonly id?: string | undefined;
-        readonly props: InsertableTreeNodeFromImplicitAllowedTypes<TPropsSchema> | (undefined & InsertableTreeNodeFromImplicitAllowedTypes<TPropsSchema>);
-    }, true, {
-        readonly id: import("./simple-tree/schemaTypes.js").FieldSchema<import("./simple-tree/schemaTypes.js").FieldKind.Identifier, import("./simple-tree/leafNodeSchema.js").LeafSchema<"string", string>, unknown>;
-        readonly props: import("./simple-tree/schemaTypes.js").FieldSchema<import("./simple-tree/schemaTypes.js").FieldKind.Required, TPropsSchema, unknown>;
-    }>;
+    function createColumn<const TScope extends string | undefined>({ schemaFactory, }: System_TableSchema.CreateColumnOptionsBase<SchemaFactoryAlpha<TScope>>): System_TableSchema.ColumnSchemaBase<TScope, System_TableSchema.DefaultPropsType>;
     /**
-     * Base column schema type.
-     * @sealed @system @internal
+     * Factory for creating new table column schema.
+     * @internal
      */
-    type ColumnSchemaBase<TScope extends string | undefined, TPropsSchema extends ImplicitAllowedTypes> = ReturnType<typeof createColumn<TScope, TPropsSchema>>;
+    function createColumn<const TScope extends string | undefined, const TProps extends ImplicitAnnotatedFieldSchema>({ schemaFactory, props, }: System_TableSchema.CreateColumnOptionsBase<SchemaFactoryAlpha<TScope>> & {
+        /**
+         * Optional column properties.
+         */
+        readonly props: TProps;
+    }): System_TableSchema.ColumnSchemaBase<TScope, TProps>;
     /**
      * A row in a table.
-     * @remarks Implemented by the schema class returned from {@link TableSchema.createRow}.
+     * @remarks Implemented by the schema class returned from {@link TableSchema.(createRow:2)}.
      * @sealed @internal
      */
-    interface IRow<TCellSchema extends ImplicitAllowedTypes, TPropsSchema extends ImplicitAllowedTypes = ImplicitAllowedTypes> {
+    interface Row<TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes, TProps extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> {
         /**
          * The unique identifier of the row.
          * @remarks Uniquely identifies the node within the entire tree, not just the table.
@@ -61,83 +282,80 @@ export declare namespace TableSchema {
         /**
          * Gets the cell in the specified column.
          * @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: IColumn): TreeNodeFromImplicitAllowedTypes<TCellSchema> | undefined;
+        getCell(column: Column): 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<TCellSchema> | undefined;
+        getCell(columnId: string): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
         /**
          * Sets the cell in the specified column.
-         * @remarks To remove a cell, call {@link TableSchema.IRow.(removeCell:1)} instead.
+         * @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: IColumn, value: InsertableTreeNodeFromImplicitAllowedTypes<TCellSchema>): void;
+        setCell(column: Column, value: InsertableTreeNodeFromImplicitAllowedTypes<TCell>): void;
         /**
          * Sets the cell in the specified column, denoted by column ID.
-         * @remarks To remove a cell, call {@link TableSchema.IRow.(removeCell:2)} instead.
+         * @remarks To remove a cell, call {@link TableSchema.Row.(removeCell:2)} instead.
          */
-        setCell(columnId: string, value: InsertableTreeNodeFromImplicitAllowedTypes<TCellSchema>): void;
+        setCell(columnId: string, value: InsertableTreeNodeFromImplicitAllowedTypes<TCell>): void;
         /**
          * Removes the cell in the specified column.
-         * @privateRemarks TODO: return removed cell
+         * @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: IColumn): void;
+        removeCell(column: Column): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
         /**
          * Removes the cell in the specified column, denoted by column ID.
-         * @privateRemarks TODO: return removed cell
+         * @returns The cell if it exists, otherwise undefined.
          */
-        removeCell(columnId: string): void;
+        removeCell(columnId: string): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
         /**
-         * User-provided row properties.
+         * The row's properties.
+         * @remarks This is a user-defined schema that can be used to store additional information about the row.
+         * @privateRemarks
+         * Note: these docs are duplicated on the inline type definitions in {@link createColumn}.
+         * If you update the docs here, please also update the inline type definitions.
          */
-        get props(): TreeNodeFromImplicitAllowedTypes<TPropsSchema>;
-        set props(value: InsertableTreeNodeFromImplicitAllowedTypes<TPropsSchema>);
+        get props(): TreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TProps>>;
+        set props(value: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TProps>>);
     }
     /**
-     * Factory for creating new table row schema.
-     *
-     * @privateRemarks
-     * TODO:
-     * - Add overloads to make propsSchema optional.
-     * - Take field schema rather than node schema for `propsSchema`, in particular to allow making
-     * the additional properties optional.
-     *
-     * @sealed @internal
+     * Factory for creating new table column schema.
+     * @internal
      */
-    function createRow<const TInputScope extends string | undefined, const TCellSchema extends ImplicitAllowedTypes, const TPropsSchema extends ImplicitAllowedTypes>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, cellSchema: TCellSchema, propsSchema: TPropsSchema): TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row">, NodeKind.Object, TreeNode & IRow<TCellSchema, TPropsSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row">, NodeKind, unknown>, object & {
-        readonly id?: string | undefined;
-        readonly cells: (import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, true, TCellSchema, import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema> | undefined) => import("./simple-tree/mapNode.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, true, TCellSchema, import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema> | undefined) => import("./simple-tree/mapNode.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>)> | undefined) & import("./simple-tree/schemaTypes.js").InsertableTypedNode<import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, true, TCellSchema, import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema> | undefined) => import("./simple-tree/mapNode.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>), import("./simple-tree/index.js").TreeNodeSchemaCore<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, true, TCellSchema, import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema> | undefined) => import("./simple-tree/mapNode.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>)>;
-        readonly props: InsertableTreeNodeFromImplicitAllowedTypes<TPropsSchema> | (undefined & InsertableTreeNodeFromImplicitAllowedTypes<TPropsSchema>);
-    }, true, {
-        readonly id: import("./simple-tree/schemaTypes.js").FieldSchema<import("./simple-tree/schemaTypes.js").FieldKind.Identifier, import("./simple-tree/leafNodeSchema.js").LeafSchema<"string", string>, unknown>;
-        readonly cells: TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, import("./simple-tree/mapNode.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>, import("./simple-tree/mapNode.js").MapNodeInsertableData<TCellSchema>, true, TCellSchema, undefined>;
-        readonly props: import("./simple-tree/schemaTypes.js").FieldSchema<import("./simple-tree/schemaTypes.js").FieldKind.Required, TPropsSchema, unknown>;
-    }>;
+    function createRow<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes>({ schemaFactory, cell, }: System_TableSchema.CreateRowOptionsBase<SchemaFactoryAlpha<TScope>, TCell>): System_TableSchema.RowSchemaBase<TScope, TCell, System_TableSchema.DefaultPropsType>;
     /**
-     * Base row schema type.
-     * @sealed @system @internal
+     * Factory for creating new table column schema.
+     * @internal
      */
-    type RowSchemaBase<TScope extends string | undefined, TCellSchema extends ImplicitAllowedTypes, TPropsSchema extends ImplicitAllowedTypes> = ReturnType<typeof createRow<TScope, TCellSchema, TPropsSchema>>;
+    function createRow<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TProps extends ImplicitAnnotatedFieldSchema>({ schemaFactory, cell, props, }: System_TableSchema.CreateRowOptionsBase<SchemaFactoryAlpha<TScope>, TCell> & {
+        /**
+         * Optional row properties.
+         */
+        readonly props: TProps;
+    }): System_TableSchema.RowSchemaBase<TScope, TCell, TProps>;
     /**
-     * A key to uniquely identify a cell in a table.
-     * @sealed @internal
+     * A key to uniquely identify a cell within a table.
+     * @internal
      */
-    interface CellKey {
+    interface CellKey<TColumn extends ImplicitAllowedTypes, TRow extends ImplicitAllowedTypes> {
         /**
-         * {@link TableSchema.IColumn.id} of the containing {@link TableSchema.IColumn}.
+         * {@link TableSchema.Column} or {@link TableSchema.Column.id} at which the cell is located.
          */
-        readonly columnId: string;
+        readonly column: string | TreeNodeFromImplicitAllowedTypes<TColumn>;
         /**
-         * {@link TableSchema.IRow.id} of the containing {@link TableSchema.IRow}.
+         * {@link TableSchema.Row} or {@link TableSchema.Row.id} at which the cell is located.
          */
-        readonly rowId: string;
+        readonly row: string | TreeNodeFromImplicitAllowedTypes<TRow>;
     }
     /**
-     * {@link TableSchema.ITable.insertColumn} parameters.
-     * @sealed @internal
+     * {@link TableSchema.Table.insertColumn} parameters.
+     * @internal
      */
-    interface InsertColumnParameters<TInsertableColumn> {
+    interface InsertColumnParameters<TColumn extends ImplicitAllowedTypes> {
         /**
          * The index at which to insert the new column.
          * @remarks If not provided, the column will be appended to the end of the table.
@@ -146,13 +364,43 @@ export declare namespace TableSchema {
         /**
          * The column to insert.
          */
-        readonly column: TInsertableColumn;
+        readonly column: InsertableTreeNodeFromImplicitAllowedTypes<TColumn>;
     }
     /**
-     * {@link TableSchema.ITable.insertRows} parameters.
-     * @sealed @internal
+     * {@link TableSchema.Table.insertColumns} parameters.
+     * @internal
+     */
+    interface InsertColumnsParameters<TColumn extends ImplicitAllowedTypes> {
+        /**
+         * The index at which to insert the new columns.
+         * @remarks If not provided, the columns will be appended to the end of the table.
+         */
+        readonly index?: number | undefined;
+        /**
+         * The columns to insert.
+         */
+        readonly columns: InsertableTreeNodeFromImplicitAllowedTypes<TColumn>[];
+    }
+    /**
+     * {@link TableSchema.Table.insertRow} parameters.
+     * @internal
      */
-    interface InsertRowsParameters<TInsertableRow> {
+    interface InsertRowParameters<TRow extends ImplicitAllowedTypes> {
+        /**
+         * The index at which to insert the new row.
+         * @remarks If not provided, the row will be appended to the end of the table.
+         */
+        readonly index?: number | undefined;
+        /**
+         * The row to insert.
+         */
+        readonly row: InsertableTreeNodeFromImplicitAllowedTypes<TRow>;
+    }
+    /**
+     * {@link TableSchema.Table.insertRows} parameters.
+     * @internal
+     */
+    interface InsertRowsParameters<TRow extends ImplicitAllowedTypes> {
         /**
          * The index at which to insert the new rows.
          * @remarks If not provided, the rows will be appended to the end of the table.
@@ -161,119 +409,201 @@ export declare namespace TableSchema {
         /**
          * The rows to insert.
          */
-        readonly rows: TInsertableRow[];
+        readonly rows: InsertableTreeNodeFromImplicitAllowedTypes<TRow>[];
     }
     /**
-     * {@link TableSchema.ITable.setCell} parameters.
-     * @sealed @internal
+     * {@link TableSchema.Table.setCell} parameters.
+     * @internal
      */
-    interface SetCellParameters<TInsertableCell> {
+    interface SetCellParameters<TCell extends ImplicitAllowedTypes, TColumn extends ImplicitAllowedTypes, TRow extends ImplicitAllowedTypes> {
         /**
          * The key to uniquely identify a cell in a table.
          */
-        readonly key: CellKey;
+        readonly key: CellKey<TColumn, TRow>;
         /**
          * The cell to set.
          */
-        readonly cell: TInsertableCell;
+        readonly cell: InsertableTreeNodeFromImplicitAllowedTypes<TCell>;
     }
     /**
      * A table.
      * @sealed @internal
      */
-    interface ITable<TCellSchema extends ImplicitAllowedTypes, TColumnSchema extends ImplicitAllowedTypes, TRowSchema extends ImplicitAllowedTypes> {
+    interface Table<TCell extends ImplicitAllowedTypes, TColumn extends ImplicitAllowedTypes, TRow extends ImplicitAllowedTypes> {
         /**
          * The table's columns.
          */
-        readonly columns: TreeArrayNode<TColumnSchema>;
+        readonly columns: TreeArrayNode<TColumn>;
         /**
          * The table's rows.
          */
-        readonly rows: TreeArrayNode<TRowSchema>;
+        readonly rows: TreeArrayNode<TRow>;
         /**
-         * Gets a table column by its {@link TableSchema.IRow.id}.
+         * Gets a table column by its {@link TableSchema.Column.id}.
          */
-        getColumn(id: string): TreeNodeFromImplicitAllowedTypes<TColumnSchema> | undefined;
+        getColumn(id: string): TreeNodeFromImplicitAllowedTypes<TColumn> | undefined;
         /**
-         * Gets a table row by its {@link TableSchema.IRow.id}.
+         * Gets a table row by its {@link TableSchema.Row.id}.
          */
-        getRow(id: string): TreeNodeFromImplicitAllowedTypes<TRowSchema> | undefined;
+        getRow(id: string): TreeNodeFromImplicitAllowedTypes<TRow> | undefined;
         /**
          * Gets a cell in the table by column and row IDs.
          * @param key - A key that uniquely distinguishes a cell in the table, represented as a combination of the column ID and row ID.
-         * @privateRemarks TODO: add overload that takes row and column nodes.
          */
-        getCell(key: CellKey): TreeNodeFromImplicitAllowedTypes<TCellSchema> | undefined;
+        getCell(key: CellKey<TColumn, TRow>): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
         /**
          * Inserts a column into the table.
-         * @throws Throws an error if the column is already in the tree, or if the specified index is out of range.
+         *
+         * @throws
+         * Throws an error in the following cases:
+         *
+         * - The column, or a column with the same ID is already in the tree.
+         *
+         * - The specified index is out of range.
+         *
+         * No column is inserted in these cases.
+         */
+        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.
+         *
+         * No columns are inserted in these cases.
+         */
+        insertColumns(params: InsertColumnsParameters<TColumn>): TreeNodeFromImplicitAllowedTypes<TColumn>[];
+        /**
+         * Inserts a row into the table.
+         *
+         * @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.
+         *
+         * No row is inserted in these cases.
          */
-        insertColumn(params: InsertColumnParameters<InsertableTreeNodeFromImplicitAllowedTypes<TColumnSchema>>): TreeNodeFromImplicitAllowedTypes<TColumnSchema>;
+        insertRow(params: InsertRowParameters<TRow>): TreeNodeFromImplicitAllowedTypes<TRow>;
         /**
          * Inserts 0 or more rows into the table.
-         * @throws Throws an error if any of the rows are already in the tree, or if the specified index is out of range.
+         *
+         * @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.
+         *
+         * No rows are inserted in these cases.
          */
-        insertRows(params: InsertRowsParameters<InsertableTreeNodeFromImplicitAllowedTypes<TRowSchema>>): TreeNodeFromImplicitAllowedTypes<TRowSchema>[];
+        insertRows(params: InsertRowsParameters<TRow>): TreeNodeFromImplicitAllowedTypes<TRow>[];
         /**
          * Sets the cell at the specified location in the table.
-         * @remarks To remove a cell, call {@link TableSchema.ITable.removeCell} instead.
-         * @privateRemarks TODO: add overload that takes column/row nodes?
+         * @remarks To remove a cell, call {@link TableSchema.Table.removeCell} instead.
          */
-        setCell(params: SetCellParameters<InsertableTreeNodeFromImplicitAllowedTypes<TCellSchema>>): void;
+        setCell(params: SetCellParameters<TCell, TColumn, TRow>): void;
         /**
          * Removes the specified column from the table.
-         * @remarks Note: this does not remove any cells from the table's rows.
-         * @privateRemarks
-         * TODO:
-         * - Policy for when the column is not in the table.
-         * - Actually remove corresponding cells from table rows.
+         *
+         * @remarks
+         * Note: this does not remove any cells from the table's rows.
+         * To remove the corresponding cells, use {@link TableSchema.Table.removeCell}.
+         *
+         * @param column - The {@link TableSchema.Column | column} or {@link TableSchema.Column.id | column ID} to remove.
+         * @throws Throws an error if the column is not in the table.
+         * @privateRemarks TODO (future): Actually remove corresponding cells from table rows.
+         */
+        removeColumn(column: string | TreeNodeFromImplicitAllowedTypes<TColumn>): TreeNodeFromImplicitAllowedTypes<TColumn>;
+        /**
+         * Removes 0 or more columns from the table.
+         *
+         * @remarks
+         * Note: this does not remove any cells from the table's rows.
+         * To remove the corresponding cells, use {@link TableSchema.Table.removeCell}.
+         *
+         * @param columns - The columns to remove.
+         * @throws Throws an error if any of the columns are not in the table.
+         * In this case, no columns are removed.
+         */
+        removeColumns(columns: readonly TreeNodeFromImplicitAllowedTypes<TColumn>[]): TreeNodeFromImplicitAllowedTypes<TColumn>[];
+        /**
+         * Removes 0 or more columns from the table.
+         *
+         * @remarks
+         * Note: this does not remove any cells from the table's rows.
+         * To remove the corresponding cells, use {@link TableSchema.Table.removeCell}.
+         *
+         * @param columns - The columns to remove, specified by their {@link TableSchema.Column.id}.
+         * @throws Throws an error if any of the columns are not in the table.
+         * In this case, no columns are removed.
+         */
+        removeColumns(columns: readonly string[]): TreeNodeFromImplicitAllowedTypes<TColumn>[];
+        /**
+         * Removes all columns from the table.
+         * @returns The removed columns.
+         */
+        removeAllColumns(): TreeNodeFromImplicitAllowedTypes<TColumn>[];
+        /**
+         * Removes the specified row from the table.
+         * @param row - The {@link TableSchema.Row | row} or {@link TableSchema.Row.id | row ID} to remove.
+         * @throws Throws an error if the row is not in the table.
          */
-        removeColumn: (column: TreeNodeFromImplicitAllowedTypes<TColumnSchema>) => void;
+        removeRow(row: string | TreeNodeFromImplicitAllowedTypes<TRow>): TreeNodeFromImplicitAllowedTypes<TRow>;
         /**
          * Removes 0 or more rows from the table.
-         * @privateRemarks TODO: policy for when 1 or more rows are not in the table.
+         * @param rows - The rows to remove.
+         * @throws Throws an error if any of the rows are not in the table.
+         * In this case, no rows are removed.
          */
-        removeRows: (rows: readonly TreeNodeFromImplicitAllowedTypes<TRowSchema>[]) => void;
+        removeRows(rows: readonly TreeNodeFromImplicitAllowedTypes<TRow>[]): TreeNodeFromImplicitAllowedTypes<TRow>[];
+        /**
+         * Removes 0 or more rows from the table.
+         * @param rows - The rows to remove, specified by their {@link TableSchema.Row.id}.
+         * @throws Throws an error if any of the rows are not in the table.
+         * In this case, no rows are removed.
+         */
+        removeRows(rows: readonly string[]): TreeNodeFromImplicitAllowedTypes<TRow>[];
         /**
          * Removes all rows from the table.
+         * @returns The removed rows.
          */
-        removeAllRows: () => void;
+        removeAllRows(): TreeNodeFromImplicitAllowedTypes<TRow>[];
         /**
          * Removes the cell at the specified location in the table.
-         * @privateRemarks TODO: add overload that takes column/row nodes?
+         * @returns The cell if it exists, otherwise undefined.
+         * @throws Throws an error if the location does not exist in the table.
          */
-        removeCell: (key: CellKey) => void;
+        removeCell(key: CellKey<TColumn, TRow>): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
     }
     /**
      * Factory for creating new table schema without specifying row or column schema.
      * @internal
      */
-    function createTable<const TInputScope extends string | undefined, const TCell extends ImplicitAllowedTypes>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, _cellSchema: TCell): ReturnType<typeof createTableInternal<TInputScope, TCell>>;
+    function createTable<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes>({ schemaFactory, cell, }: 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>>;
     /**
-     * Factory for creating new table schema without specifying row schema
+     * Factory for creating new table schema without specifying row schema.
      * @internal
      */
-    function createTable<const TInputScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TColumn extends ColumnSchemaBase<TInputScope, ImplicitAllowedTypes>>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, _cellSchema: TCell, columnSchema: TColumn): ReturnType<typeof createTableInternal<TInputScope, TCell, TColumn>>;
+    function createTable<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TColumn extends System_TableSchema.ColumnSchemaBase<TScope>>({ schemaFactory, cell, column, }: 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
      */
-    function createTable<const TInputScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TColumn extends ColumnSchemaBase<TInputScope, ImplicitAllowedTypes>, const TRow extends RowSchemaBase<TInputScope, TCell, ImplicitAllowedTypes>>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, _cellSchema: TCell, columnSchema: TColumn, rowSchema: TRow): ReturnType<typeof createTableInternal<TInputScope, TCell, TColumn, TRow>>;
-    /**
-     * Factory for creating new table schema.
-     * @system @internal
-     */
-    function createTableInternal<const TInputScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TColumn extends ColumnSchemaBase<TInputScope, ImplicitAllowedTypes> = ColumnSchemaBase<TInputScope, ImplicitAllowedTypes>, const TRow extends RowSchemaBase<TInputScope, TCell, ImplicitAllowedTypes> = RowSchemaBase<TInputScope, TCell, ImplicitAllowedTypes>>(inputSchemaFactory: SchemaFactoryAlpha<TInputScope>, _cellSchema: TCell, columnSchema: TColumn, rowSchema: TRow): TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table">, NodeKind.Object, TreeNode & ITable<TCell, TColumn, TRow> & 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, TRow, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRow>>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRow>> | undefined) => TreeArrayNode<TRow, [TRow] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRow> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRow] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRow> : 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, TRow, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRow>>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRow>> | undefined) => TreeArrayNode<TRow, [TRow] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRow> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRow] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRow> : 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, TRow, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRow>>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRow>> | undefined) => TreeArrayNode<TRow, [TRow] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRow> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRow] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRow> : 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, TRow, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRow>>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TRow>> | undefined) => TreeArrayNode<TRow, [TRow] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRow> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRow] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRow> : 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, TColumn, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumn>>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumn>> | undefined) => TreeArrayNode<TColumn, [TColumn] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumn> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumn] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumn> : 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, TColumn, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumn>>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumn>> | undefined) => TreeArrayNode<TColumn, [TColumn] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumn> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumn] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumn> : 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, TColumn, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumn>>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumn>> | undefined) => TreeArrayNode<TColumn, [TColumn] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumn> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumn] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumn> : 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, TColumn, Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumn>>, unknown> & (new (data?: import("./simple-tree/index.js").InternalTreeNode | Iterable<InsertableTreeNodeFromImplicitAllowedTypes<TColumn>> | undefined) => TreeArrayNode<TColumn, [TColumn] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumn> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumn] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumn> : 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, {
-        readonly rows: TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.rows">, NodeKind.Array, TreeArrayNode<TRow, [TRow] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TRow> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TRow] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TRow> : 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<TRow>>, true, TRow, undefined>;
-        readonly columns: TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Table.columns">, NodeKind.Array, TreeArrayNode<TColumn, [TColumn] extends [ImplicitAllowedTypes] ? TreeNodeFromImplicitAllowedTypes<TColumn> : TreeNodeFromImplicitAllowedTypes<ImplicitAllowedTypes>, [TColumn] extends [ImplicitAllowedTypes] ? InsertableTreeNodeFromImplicitAllowedTypes<TColumn> : 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<TColumn>>, true, TColumn, undefined>;
-    }>;
-    /**
-     * Base row schema type.
-     * @sealed @system @internal
-     */
-    type TableSchemaBase<TScope extends string | undefined, TCell extends ImplicitAllowedTypes, TColumn extends ColumnSchemaBase<TScope, ImplicitAllowedTypes> = ColumnSchemaBase<TScope, ImplicitAllowedTypes>, TRow extends RowSchemaBase<TScope, TCell, ImplicitAllowedTypes> = RowSchemaBase<TScope, TCell, ImplicitAllowedTypes>> = ReturnType<typeof createTable<TScope, TCell, TColumn, TRow>>;
+    function createTable<const TScope extends string | undefined, const TCell extends ImplicitAllowedTypes, const TColumn extends System_TableSchema.ColumnSchemaBase<TScope>, const TRow extends System_TableSchema.RowSchemaBase<TScope, TCell>>({ schemaFactory, cell, column, row, }: System_TableSchema.TableFactoryOptionsBase<SchemaFactoryAlpha<TScope>, TCell> & {
+        readonly column: TColumn;
+        readonly row: TRow;
+    }): System_TableSchema.TableSchemaBase<TScope, TCell, TColumn, TRow>;
 }
 //# sourceMappingURL=tableSchema.d.ts.map