/*!
 * Copyright (c) Microsoft Corporation and contributors. All rights reserved.
 * Licensed under the MIT License.
 */
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 @alpha
 */
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 @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 @alpha
     */
    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 @alpha
     */
    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 @alpha
     */
    type CreateColumnOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha, TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes> = OptionsWithSchemaFactory<TSchemaFactory> & OptionsWithCellSchema<TCell>;
    /**
     * Factory for creating column schema.
     * @system @alpha
     */
    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 ? {
        /**
         * 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 @alpha
     */
    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 @alpha
     */
    type CreateRowOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha, TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes> = OptionsWithSchemaFactory<TSchemaFactory> & OptionsWithCellSchema<TCell>;
    /**
     * Factory for creating row schema.
     * @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;
        readonly cells: (import("./simple-tree/schemaTypes.js").InsertableTypedNode<TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, import("./simple-tree/index.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>, import("./simple-tree/index.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/index.js").MapNodeInsertableData<TCellSchema>, unknown> & (new (data?: InternalTreeNode | import("./simple-tree/index.js").MapNodeInsertableData<TCellSchema> | undefined) => import("./simple-tree/index.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/index.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>, import("./simple-tree/index.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/index.js").MapNodeInsertableData<TCellSchema>, unknown> & (new (data?: InternalTreeNode | import("./simple-tree/index.js").MapNodeInsertableData<TCellSchema> | undefined) => import("./simple-tree/index.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").FieldSchemaAlpha<import("./simple-tree/schemaTypes.js").FieldKind.Required, TreeNodeSchemaClass<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, import("./simple-tree/index.js").TreeMapNode<TCellSchema> & WithType<ScopedSchemaName<ScopedSchemaName<TInputScope, "table">, "Row.cells">, NodeKind.Map, unknown>, import("./simple-tree/index.js").MapNodeInsertableData<TCellSchema>, true, TCellSchema, undefined>, unknown>;
    }>;
    /**
     * Base row schema type.
     * @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 @alpha
     */
    type TableFactoryOptionsBase<TSchemaFactory extends SchemaFactoryAlpha = SchemaFactoryAlpha, TCell extends ImplicitAllowedTypes = ImplicitAllowedTypes> = OptionsWithSchemaFactory<TSchemaFactory> & OptionsWithCellSchema<TCell>;
    /**
     * Factory for creating table schema.
     * @system @alpha
     */
    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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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/index.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 @alpha
     */
    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.
 *
 * - 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.
 *
 * 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 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 Defining a Table schema
 *
 * ```typescript
 * class MyTable extends TableSchema.table({
 * 	schemaFactory,
 * 	cell: schemaFactory.string,
 * }) {}
 *
 * const table = new MyTable({
 * 	columns: [{ id: "column-0" }],
 * 	rows: [{ id: "row-0", cells: { "column-0": "Hello world!" } }],
 * });
 * ```
 *
 * @example Customizing Column and Row schema
 *
 * ```typescript
 * const Cell = schemaFactory.string;
 *
 * class MyColumn extends TableSchema.column({
 * 	schemaFactory,
 * 	cell: Cell,
 * 	props: schemaFactory.object("TableColumnProps", {
 * 		label: schemaFactory.string,
 * 	}),
 * }) {}
 *
 * class MyRow extends TableSchema.row({
 * 	schemaFactory,
 * 	cell: Cell,
 * }) {}
 *
 * class MyTable extends TableSchema.table({
 * 	schemaFactory,
 * 	cell: Cell,
 * 	column: MyColumn,
 * 	row: MyRow,
 * }) {}
 *
 * const table = new MyTable({
 * 	columns: [
 * 		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.
 *
 * @alpha
 */
export declare namespace TableSchema {
    /**
     * A column in a table.
     * @remarks Implemented by the schema class returned from {@link TableSchema.(column:2)}.
     * @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<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.
         */
        readonly id: string;
        /**
         * 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 System_TableSchema.createColumnSchema}.
         * If you update the docs here, please also update the inline type definitions.
         */
        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.
     * @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, 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.
     * @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 TCell extends ImplicitAllowedTypes, const TProps extends ImplicitAnnotatedFieldSchema>(params: System_TableSchema.CreateColumnOptionsBase<SchemaFactoryAlpha<TScope>, TCell> & {
        /**
         * Optional column properties.
         */
        readonly props: TProps;
    }): System_TableSchema.ColumnSchemaBase<TScope, TCell, TProps>;
    /**
     * A row in a table.
     * @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, TProps extends ImplicitAnnotatedFieldSchema = ImplicitAnnotatedFieldSchema> {
        /**
         * The unique identifier of the row.
         * @remarks Uniquely identifies the node within the entire tree, not just the table.
         */
        readonly id: string;
        /**
         * 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: 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<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.
         */
        setCell(columnId: string, value: InsertableTreeNodeFromImplicitAllowedTypes<TCell>): void;
        /**
         * Removes 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.
         */
        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.
         */
        removeCell(columnId: string): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
        /**
         * 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 System_TableSchema.createRowSchema}.
         * If you update the docs here, please also update the inline type definitions.
         */
        get props(): TreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TProps>>;
        set props(value: InsertableTreeFieldFromImplicitField<UnannotateImplicitFieldSchema<TProps>>);
    }
    /**
     * Factory for creating new table column schema.
     * @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.
     * @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> & {
        /**
         * Optional row properties.
         */
        readonly props: TProps;
    }): System_TableSchema.RowSchemaBase<TScope, TCell, TProps>;
    /**
     * A key to uniquely identify a cell within a table.
     * @alpha
     */
    interface CellKey<TColumn extends ImplicitAllowedTypes, TRow extends ImplicitAllowedTypes> {
        /**
         * {@link TableSchema.Column} or {@link TableSchema.Column.id} at which the cell is located.
         */
        readonly column: string | TreeNodeFromImplicitAllowedTypes<TColumn>;
        /**
         * {@link TableSchema.Row} or {@link TableSchema.Row.id} at which the cell is located.
         */
        readonly row: string | TreeNodeFromImplicitAllowedTypes<TRow>;
    }
    /**
     * {@link TableSchema.Table.insertColumn} parameters.
     * @alpha
     */
    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.
         */
        readonly index?: number | undefined;
        /**
         * The column to insert.
         */
        readonly column: InsertableTreeNodeFromImplicitAllowedTypes<TColumn>;
    }
    /**
     * {@link TableSchema.Table.insertColumns} parameters.
     * @alpha
     */
    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.
     * @alpha
     */
    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.
     * @alpha
     */
    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.
         */
        readonly index?: number | undefined;
        /**
         * The rows to insert.
         */
        readonly rows: InsertableTreeNodeFromImplicitAllowedTypes<TRow>[];
    }
    /**
     * {@link TableSchema.Table.setCell} parameters.
     * @alpha
     */
    interface SetCellParameters<TCell extends ImplicitAllowedTypes, TColumn extends ImplicitAllowedTypes, TRow extends ImplicitAllowedTypes> {
        /**
         * The key to uniquely identify a cell in a table.
         */
        readonly key: CellKey<TColumn, TRow>;
        /**
         * The cell to set.
         */
        readonly cell: InsertableTreeNodeFromImplicitAllowedTypes<TCell>;
    }
    /**
     * A table.
     * @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<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.
         */
        readonly columns: TreeArrayNode<TColumn>;
        /**
         * The table's rows.
         */
        readonly rows: TreeArrayNode<TRow>;
        /**
         * Gets a table column by its {@link TableSchema.Column.id}.
         */
        getColumn(id: string): TreeNodeFromImplicitAllowedTypes<TColumn> | undefined;
        /**
         * Gets a table row by its {@link TableSchema.Row.id}.
         */
        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.
         */
        getCell(key: CellKey<TColumn, TRow>): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
        /**
         * Inserts a column into the table.
         *
         * @throws Throws an error if the specified index is out of range.
         *
         * 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 if the specified index is out of range.
         *
         * No columns are inserted in this case.
         */
        insertColumns(params: InsertColumnsParameters<TColumn>): TreeNodeFromImplicitAllowedTypes<TColumn>[];
        /**
         * Inserts a row into the table.
         *
         * @throws
         * Throws an error in the following cases:
         *
         * - 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.
         */
        insertRow(params: InsertRowParameters<TRow>): TreeNodeFromImplicitAllowedTypes<TRow>;
        /**
         * Inserts 0 or more rows into the table.
         *
         * @throws
         * Throws an error in the following cases:
         *
         * - 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<TRow>): TreeNodeFromImplicitAllowedTypes<TRow>[];
        /**
         * Sets the cell at the specified location in the table.
         * @remarks To remove a cell, call {@link TableSchema.Table.removeCell} instead.
         */
        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.
         * 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.
         */
        removeRow(row: string | TreeNodeFromImplicitAllowedTypes<TRow>): TreeNodeFromImplicitAllowedTypes<TRow>;
        /**
         * Removes 0 or more rows from 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<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(): TreeNodeFromImplicitAllowedTypes<TRow>[];
        /**
         * Removes the cell at the specified location in the table.
         * @returns The cell if it exists, otherwise undefined.
         * @throws Throws an error if the location does not exist in the table.
         */
        removeCell(key: CellKey<TColumn, TRow>): TreeNodeFromImplicitAllowedTypes<TCell> | undefined;
    }
    /**
     * 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, TCell, System_TableSchema.DefaultPropsType>, System_TableSchema.RowSchemaBase<TScope, TCell, System_TableSchema.DefaultPropsType>>;
    /**
     * 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, 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 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, 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>;
}
//# sourceMappingURL=tableSchema.d.ts.map