@revisium/schema-toolkit-ui 0.3.2 → 0.4.0

package/dist/index.d.mts

@@ -1,8 +1,9 @@
 import * as _revisium_schema_toolkit0 from "@revisium/schema-toolkit";
-import { Diagnostic, JsonObjectSchema, JsonPatch, JsonSchema, JsonValuePatch, RefSchemas, RowModel, SchemaModel, SchemaNode, SchemaPatch, SchemaValidationError, TableModel, TreeFormulaValidationError, ValueNode } from "@revisium/schema-toolkit";
+import { Diagnostic, InferNode, JsonObjectSchema, JsonPatch, JsonSchema, JsonValuePatch, RefSchemas, RowModel, SchemaModel, SchemaNode, SchemaPatch, SchemaValidationError, SystemSchemaIds, TableModel, TreeFormulaValidationError, ValueNode } from "@revisium/schema-toolkit";
 import { BoxProps, IconButtonProps, Tooltip as Tooltip$1 } from "@chakra-ui/react";
 import * as React$1 from "react";
-import React, { FC, FocusEventHandler, FormEventHandler, KeyboardEventHandler, RefCallback } from "react";
+import React, { FC, FocusEventHandler, FormEventHandler, KeyboardEventHandler, PropsWithChildren, RefCallback } from "react";
+import * as react_jsx_runtime19 from "react/jsx-runtime";
 export * from "@revisium/schema-toolkit";
 
 //#region src/schema-editor/model/state/TreeState.d.ts
@@ -233,7 +234,7 @@ declare class ValidationTracker {
 //#endregion
 //#region src/schema-editor/model/core/ViewState.d.ts
 type ViewMode = 'Tree' | 'Json' | 'RefBy';
-declare class ViewState {
+declare class ViewState$1 {
   private _viewMode;
   private _loading;
   constructor();
@@ -331,7 +332,7 @@ declare class SchemaEditorCore {
   private readonly _onSelectForeignKey;
   readonly accessors: AccessorCache;
   readonly validation: ValidationTracker;
-  readonly view: ViewState;
+  readonly view: ViewState$1;
   readonly collapse: CollapseManager;
   readonly keyboard: KeyboardNavigation;
   constructor(jsonSchema: JsonObjectSchema, options?: SchemaEditorCoreOptions, accessorFactory?: NodeAccessorFactory);
@@ -609,7 +610,7 @@ interface MenuItem {
   beforeSeparator?: boolean;
   afterSeparator?: boolean;
 }
-type NodeRendererType = 'string' | 'number' | 'boolean' | 'container' | 'file' | 'foreignKey';
+type NodeRendererType = 'string' | 'number' | 'boolean' | 'container' | 'file' | 'foreignKey' | 'markdown';
 interface ForeignKeySearchResult {
   ids: string[];
   hasMore: boolean;
@@ -811,6 +812,1384 @@ interface CreateButtonProps {
 }
 declare const CreateButton: React.FC<CreateButtonProps>;
 //#endregion
+//#region src/table-editor/shared/field-types.d.ts
+declare enum FilterFieldType {
+  String = "String",
+  Number = "Number",
+  Boolean = "Boolean",
+  ForeignKey = "ForeignKey",
+  File = "File",
+  DateTime = "DateTime"
+}
+//#endregion
+//#region src/table-editor/shared/system-fields.d.ts
+declare enum SystemFieldId {
+  Id = "id",
+  CreatedAt = "createdAt",
+  UpdatedAt = "updatedAt",
+  CreatedId = "createdId",
+  VersionId = "versionId",
+  PublishedAt = "publishedAt",
+  Hash = "hash",
+  SchemaHash = "schemaHash"
+}
+interface SystemFieldDef {
+  id: SystemFieldId;
+  label: string;
+  fieldType: FilterFieldType;
+  ref: SystemSchemaIds;
+}
+declare const SYSTEM_FIELDS: SystemFieldDef[];
+declare const SYSTEM_FIELD_BY_REF: ReadonlyMap<string, SystemFieldDef>;
+//#endregion
+//#region src/table-editor/shared/system-field-ids.d.ts
+declare const SYSTEM_FIELD_IDS: ReadonlySet<string>;
+//#endregion
+//#region src/table-editor/Columns/model/types.d.ts
+interface ColumnSpec {
+  field: string;
+  label: string;
+  fieldType: FilterFieldType;
+  isSystem: boolean;
+  systemFieldId?: SystemFieldId;
+  isDeprecated: boolean;
+  hasFormula: boolean;
+  foreignKeyTableId?: string;
+}
+type PinSide = 'left' | 'right';
+interface ViewColumn {
+  field: string;
+  width?: number;
+  pinned?: PinSide;
+}
+//#endregion
+//#region src/table-editor/Columns/model/extractColumns.d.ts
+declare function extractColumns(rootNode: SchemaNode): ColumnSpec[];
+//#endregion
+//#region src/table-editor/Columns/model/selectDefaultColumns.d.ts
+declare function selectDefaultColumns(columns: ColumnSpec[], maxVisible?: number): ColumnSpec[];
+//#endregion
+//#region src/table-editor/Columns/model/ColumnsModel.d.ts
+declare class ColumnsModel {
+  private _allColumns;
+  private _visibleFields;
+  private readonly _columnWidths;
+  private readonly _pinnedColumns;
+  private _onChange;
+  constructor();
+  get visibleColumns(): ColumnSpec[];
+  get hiddenColumns(): ColumnSpec[];
+  get availableFieldsToAdd(): ColumnSpec[];
+  get availableSystemFieldsToAdd(): ColumnSpec[];
+  get hasHiddenColumns(): boolean;
+  get canRemoveColumn(): boolean;
+  get sortableFields(): ColumnSpec[];
+  get filterableFields(): ColumnSpec[];
+  get pinnedLeftCount(): number;
+  get pinnedRightCount(): number;
+  init(columns: ColumnSpec[]): void;
+  showColumn(field: string): void;
+  hideColumn(field: string): void;
+  hideAll(): void;
+  addAll(): void;
+  getColumnIndex(field: string): number;
+  canMoveLeft(field: string): boolean;
+  canMoveRight(field: string): boolean;
+  canMoveToStart(field: string): boolean;
+  canMoveToEnd(field: string): boolean;
+  moveColumnLeft(field: string): void;
+  moveColumnRight(field: string): void;
+  moveColumnToStart(field: string): void;
+  moveColumnToEnd(field: string): void;
+  insertColumnBefore(targetField: string, newField: string): void;
+  insertColumnAfter(targetField: string, newField: string): void;
+  reorderColumns(fields: string[]): void;
+  setColumnWidth(field: string, width: number): void;
+  getColumnWidth(field: string): number | undefined;
+  resolveColumnWidth(field: string): number;
+  getPinState(field: string): PinSide | undefined;
+  isPinned(field: string): boolean;
+  canPinLeft(field: string): boolean;
+  canPinRight(field: string): boolean;
+  canUnpin(field: string): boolean;
+  pinLeft(field: string): void;
+  pinRight(field: string): void;
+  unpin(field: string): void;
+  getColumnStickyLeft(field: string, selectionWidth: number): number | undefined;
+  getColumnStickyRight(field: string): number | undefined;
+  isStickyLeftBoundary(field: string): boolean;
+  isStickyRightBoundary(field: string): boolean;
+  resetToDefaults(): void;
+  serializeToViewColumns(): ViewColumn[];
+  applyViewColumns(viewColumns: ViewColumn[]): void;
+  setOnChange(cb: (() => void) | null): void;
+  dispose(): void;
+  private get _visibleFieldSet();
+  private get _columnLookup();
+  private _getZone;
+  private _getZoneBounds;
+  private _pinnedLeftInsertIndex;
+  private _pinnedRightInsertIndex;
+  private _hasNeighborPin;
+  private _toViewField;
+  private _fromViewField;
+  private _notifyChange;
+}
+//#endregion
+//#region src/table-editor/Filters/model/utils/operators.d.ts
+declare enum FilterOperator {
+  Equals = "equals",
+  NotEquals = "not_equals",
+  Contains = "contains",
+  NotContains = "not_contains",
+  StartsWith = "starts_with",
+  EndsWith = "ends_with",
+  IsEmpty = "is_empty",
+  IsNotEmpty = "is_not_empty",
+  Gt = "gt",
+  Gte = "gte",
+  Lt = "lt",
+  Lte = "lte",
+  IsTrue = "is_true",
+  IsFalse = "is_false",
+  Search = "search"
+}
+interface OperatorInfo {
+  operator: FilterOperator;
+  label: string;
+  requiresValue: boolean;
+}
+declare function operatorRequiresValue(operator: FilterOperator): boolean;
+declare const OPERATORS_BY_TYPE: Readonly<Record<FilterFieldType, readonly OperatorInfo[]>>;
+declare function getOperatorLabel(operator: FilterOperator, fieldType: FilterFieldType): string;
+declare function getDefaultOperator(fieldType: FilterFieldType): FilterOperator;
+declare function getOperatorsForType(fieldType: FilterFieldType): OperatorInfo[];
+//#endregion
+//#region src/table-editor/Filters/model/utils/searchTypes.d.ts
+declare enum SearchLanguage {
+  Arabic = "arabic",
+  Armenian = "armenian",
+  Basque = "basque",
+  Catalan = "catalan",
+  Danish = "danish",
+  Dutch = "dutch",
+  English = "english",
+  Finnish = "finnish",
+  French = "french",
+  German = "german",
+  Greek = "greek",
+  Hindi = "hindi",
+  Hungarian = "hungarian",
+  Indonesian = "indonesian",
+  Irish = "irish",
+  Italian = "italian",
+  Lithuanian = "lithuanian",
+  Nepali = "nepali",
+  Norwegian = "norwegian",
+  Portuguese = "portuguese",
+  Romanian = "romanian",
+  Russian = "russian",
+  Serbian = "serbian",
+  Simple = "simple",
+  Spanish = "spanish",
+  Swedish = "swedish",
+  Tamil = "tamil",
+  Turkish = "turkish",
+  Yiddish = "yiddish"
+}
+declare enum SearchType {
+  Plain = "plain",
+  Phrase = "phrase",
+  Prefix = "prefix",
+  Tsquery = "tsquery"
+}
+declare const SEARCH_LANGUAGES: readonly {
+  value: SearchLanguage;
+  label: string;
+}[];
+declare const SEARCH_TYPES: readonly {
+  value: SearchType;
+  label: string;
+}[];
+//#endregion
+//#region src/table-editor/Filters/model/types.d.ts
+interface FilterCondition {
+  id: string;
+  field: string;
+  fieldType: FilterFieldType;
+  operator: FilterOperator;
+  value: string;
+  searchLanguage?: string;
+  searchType?: string;
+}
+interface FilterGroup {
+  id: string;
+  logic: 'and' | 'or';
+  conditions: FilterCondition[];
+  groups: FilterGroup[];
+}
+//#endregion
+//#region src/table-editor/Filters/model/filterSchema.d.ts
+declare const CONDITION_SCHEMA: {
+  type: "object";
+  additionalProperties: false;
+  required: string[];
+  properties: Record<string, _revisium_schema_toolkit0.JsonSchema>;
+  title?: string;
+  description?: string;
+  deprecated?: boolean;
+} & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+  readonly properties: {
+    readonly id: _revisium_schema_toolkit0.JsonStringSchema;
+    readonly field: _revisium_schema_toolkit0.JsonStringSchema;
+    readonly fieldType: _revisium_schema_toolkit0.JsonStringSchema;
+    readonly operator: _revisium_schema_toolkit0.JsonStringSchema;
+    readonly value: _revisium_schema_toolkit0.JsonStringSchema;
+    readonly searchLanguage: _revisium_schema_toolkit0.JsonStringSchema;
+    readonly searchType: _revisium_schema_toolkit0.JsonStringSchema;
+  };
+};
+declare const NESTED_GROUP_SCHEMA: {
+  type: "object";
+  additionalProperties: false;
+  required: string[];
+  properties: Record<string, _revisium_schema_toolkit0.JsonSchema>;
+  title?: string;
+  description?: string;
+  deprecated?: boolean;
+} & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+  readonly properties: {
+    readonly id: _revisium_schema_toolkit0.JsonStringSchema;
+    readonly logic: _revisium_schema_toolkit0.JsonStringSchema;
+    readonly conditions: {
+      type: "array";
+      items: _revisium_schema_toolkit0.JsonSchema;
+      title?: string;
+      description?: string;
+      deprecated?: boolean;
+    } & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+      readonly items: {
+        type: "object";
+        additionalProperties: false;
+        required: string[];
+        properties: Record<string, _revisium_schema_toolkit0.JsonSchema>;
+        title?: string;
+        description?: string;
+        deprecated?: boolean;
+      } & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+        readonly properties: {
+          readonly id: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly field: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly fieldType: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly operator: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly value: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly searchLanguage: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly searchType: _revisium_schema_toolkit0.JsonStringSchema;
+        };
+      };
+    };
+  };
+};
+declare const FILTER_SCHEMA: {
+  type: "object";
+  additionalProperties: false;
+  required: string[];
+  properties: Record<string, _revisium_schema_toolkit0.JsonSchema>;
+  title?: string;
+  description?: string;
+  deprecated?: boolean;
+} & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+  readonly properties: {
+    readonly id: _revisium_schema_toolkit0.JsonStringSchema;
+    readonly logic: _revisium_schema_toolkit0.JsonStringSchema;
+    readonly conditions: {
+      type: "array";
+      items: _revisium_schema_toolkit0.JsonSchema;
+      title?: string;
+      description?: string;
+      deprecated?: boolean;
+    } & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+      readonly items: {
+        type: "object";
+        additionalProperties: false;
+        required: string[];
+        properties: Record<string, _revisium_schema_toolkit0.JsonSchema>;
+        title?: string;
+        description?: string;
+        deprecated?: boolean;
+      } & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+        readonly properties: {
+          readonly id: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly field: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly fieldType: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly operator: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly value: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly searchLanguage: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly searchType: _revisium_schema_toolkit0.JsonStringSchema;
+        };
+      };
+    };
+    readonly groups: {
+      type: "array";
+      items: _revisium_schema_toolkit0.JsonSchema;
+      title?: string;
+      description?: string;
+      deprecated?: boolean;
+    } & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+      readonly items: {
+        type: "object";
+        additionalProperties: false;
+        required: string[];
+        properties: Record<string, _revisium_schema_toolkit0.JsonSchema>;
+        title?: string;
+        description?: string;
+        deprecated?: boolean;
+      } & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+        readonly properties: {
+          readonly id: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly logic: _revisium_schema_toolkit0.JsonStringSchema;
+          readonly conditions: {
+            type: "array";
+            items: _revisium_schema_toolkit0.JsonSchema;
+            title?: string;
+            description?: string;
+            deprecated?: boolean;
+          } & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+            readonly items: {
+              type: "object";
+              additionalProperties: false;
+              required: string[];
+              properties: Record<string, _revisium_schema_toolkit0.JsonSchema>;
+              title?: string;
+              description?: string;
+              deprecated?: boolean;
+            } & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+              readonly properties: {
+                readonly id: _revisium_schema_toolkit0.JsonStringSchema;
+                readonly field: _revisium_schema_toolkit0.JsonStringSchema;
+                readonly fieldType: _revisium_schema_toolkit0.JsonStringSchema;
+                readonly operator: _revisium_schema_toolkit0.JsonStringSchema;
+                readonly value: _revisium_schema_toolkit0.JsonStringSchema;
+                readonly searchLanguage: _revisium_schema_toolkit0.JsonStringSchema;
+                readonly searchType: _revisium_schema_toolkit0.JsonStringSchema;
+              };
+            };
+          };
+        };
+      };
+    };
+    readonly nextConditionId: _revisium_schema_toolkit0.JsonNumberSchema;
+    readonly nextGroupId: _revisium_schema_toolkit0.JsonNumberSchema;
+  };
+};
+type ConditionNode = InferNode<typeof CONDITION_SCHEMA>;
+type NestedGroupNode = InferNode<typeof NESTED_GROUP_SCHEMA>;
+type FilterRootNode = InferNode<typeof FILTER_SCHEMA>;
+//#endregion
+//#region src/table-editor/Filters/model/vm/FilterConditionVM.d.ts
+declare class FilterConditionVM {
+  private readonly _node;
+  constructor(_node: ConditionNode);
+  get id(): string;
+  get field(): string;
+  get fieldType(): FilterFieldType;
+  get operator(): FilterOperator;
+  get value(): string;
+  get searchLanguage(): SearchLanguage;
+  get searchType(): SearchType;
+}
+//#endregion
+//#region src/table-editor/Filters/model/vm/FilterGroupVM.d.ts
+declare class FilterGroupVM {
+  private readonly _node;
+  private readonly _isRoot;
+  constructor(_node: FilterRootNode | NestedGroupNode, isRoot?: boolean);
+  get id(): string;
+  get logic(): 'and' | 'or';
+  get conditions(): FilterConditionVM[];
+  get groups(): FilterGroupVM[];
+}
+//#endregion
+//#region src/table-editor/Filters/model/core/FilterCore.d.ts
+declare class FilterCore {
+  private readonly _row;
+  private readonly _treeOps;
+  private readonly _serializer;
+  private readonly _validator;
+  private _availableFields;
+  private _onChange;
+  private _onApply;
+  private _isOpen;
+  private _committedHasFilters;
+  constructor();
+  private static _emptyFilterData;
+  get isOpen(): boolean;
+  setOpen(value: boolean): void;
+  get rootGroup(): FilterGroupVM;
+  get hasPendingChanges(): boolean;
+  get totalConditionCount(): number;
+  get hasActiveFilters(): boolean;
+  get allFiltersValid(): boolean;
+  get isEmpty(): boolean;
+  hasFilterForField(field: string): boolean;
+  get showBadge(): boolean;
+  buildCurrentWhereClause(): Record<string, unknown> | null;
+  init(availableFields: ColumnSpec[]): void;
+  addCondition(groupId?: string): void;
+  addConditionForField(field: string): void;
+  updateCondition(id: string, updates: Partial<Pick<FilterConditionVM, 'field' | 'operator' | 'value' | 'searchLanguage' | 'searchType'>>): void;
+  removeCondition(id: string): void;
+  addGroup(): void;
+  removeGroup(id: string): void;
+  setGroupLogic(id: string, logic: 'and' | 'or'): void;
+  apply(): void;
+  applyAndClose(): void;
+  reset(): void;
+  applySnapshot(serialized: string): void;
+  clearAll(): void;
+  clearAllAndClose(): void;
+  isConditionValid(id: string): boolean;
+  getConditionError(id: string): string | null;
+  serializeRootGroup(): FilterGroup;
+  setOnChange(cb: (() => void) | null): void;
+  setOnApply(cb: ((where: Record<string, unknown> | null) => void) | null): void;
+  dispose(): void;
+  private _fireOnApply;
+  private _notifyChange;
+}
+//#endregion
+//#region src/table-editor/Filters/model/utils/filterBuilder.d.ts
+declare function buildWhereClause(group: FilterGroup): Record<string, unknown> | null;
+//#endregion
+//#region src/table-editor/Filters/ui/FilterWidget/FilterWidget.d.ts
+interface FilterWidgetProps {
+  model: FilterCore;
+  availableFields: ColumnSpec[];
+}
+declare const FilterWidget: (({
+  model,
+  availableFields
+}: FilterWidgetProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Filters/ui/FilterGroupView/FilterGroupView.d.ts
+interface FilterGroupViewProps {
+  model: FilterCore;
+  group: FilterGroupVM;
+  availableFields: ColumnSpec[];
+  isRoot?: boolean;
+}
+declare const FilterGroupView: (({
+  model,
+  group,
+  availableFields,
+  isRoot
+}: FilterGroupViewProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Filters/ui/FilterConditionView/FilterConditionView.d.ts
+interface FilterConditionViewProps {
+  model: FilterCore;
+  condition: FilterConditionVM;
+  availableFields: ColumnSpec[];
+}
+declare const FilterConditionView: (({
+  model,
+  condition,
+  availableFields
+}: FilterConditionViewProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Filters/ui/FieldSelect/FieldSelect.d.ts
+interface FieldSelectProps {
+  value: string;
+  fieldType: FilterFieldType;
+  fields: ColumnSpec[];
+  onChange: (field: string) => void;
+}
+declare const FieldSelect: (({
+  value,
+  fieldType,
+  fields,
+  onChange
+}: FieldSelectProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Filters/ui/OperatorSelect/OperatorSelect.d.ts
+interface OperatorSelectProps {
+  value: FilterOperator;
+  fieldType: FilterFieldType;
+  onChange: (operator: FilterOperator) => void;
+}
+declare const OperatorSelect: (({
+  value,
+  fieldType,
+  onChange
+}: OperatorSelectProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Filters/ui/FilterValueInput/FilterValueInput.d.ts
+interface FilterValueInputProps {
+  value: string;
+  fieldType: FilterFieldType;
+  onChange: (value: string) => void;
+  error?: string | null;
+}
+declare const FilterValueInput: (({
+  value,
+  fieldType,
+  onChange,
+  error
+}: FilterValueInputProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Search/model/SearchModel.d.ts
+declare class SearchModel {
+  private _query;
+  private _debouncedQuery;
+  private readonly _debounce;
+  private readonly _onSearch;
+  constructor(onSearch: (query: string) => void, delay?: number);
+  get query(): string;
+  get debouncedQuery(): string;
+  get hasActiveSearch(): boolean;
+  setQuery(value: string): void;
+  clear(): void;
+  dispose(): void;
+}
+//#endregion
+//#region src/table-editor/Search/ui/SearchWidget.d.ts
+interface SearchWidgetProps {
+  model: SearchModel;
+}
+declare const SearchWidget: (({
+  model
+}: SearchWidgetProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Sortings/model/types.d.ts
+interface SortEntry {
+  field: string;
+  direction: 'asc' | 'desc';
+}
+interface ViewSort {
+  field: string;
+  direction: string;
+}
+//#endregion
+//#region src/table-editor/Sortings/model/SortModel.d.ts
+declare class SortModel {
+  private readonly _row;
+  private _availableFields;
+  private _isOpen;
+  private _onChange;
+  private _onApply;
+  constructor();
+  private get _rootNode();
+  get sorts(): SortEntry[];
+  get hasSorts(): boolean;
+  get sortCount(): number;
+  get isOpen(): boolean;
+  get hasPendingChanges(): boolean;
+  setOpen(value: boolean): void;
+  get availableFields(): ColumnSpec[];
+  private get _fieldLookup();
+  private _findIndex;
+  private _setItemChild;
+  init(availableFields: ColumnSpec[]): void;
+  apply(): void;
+  applyAndClose(): void;
+  addSort(field: string, direction?: 'asc' | 'desc'): void;
+  replaceField(oldField: string, newField: string): void;
+  getSortDirection(field: string): 'asc' | 'desc' | null;
+  getSortIndex(field: string): number | null;
+  isSorted(field: string): boolean;
+  setSingleSort(field: string, direction: 'asc' | 'desc'): void;
+  setDirection(field: string, direction: 'asc' | 'desc'): void;
+  removeSort(field: string): void;
+  toggleDirection(field: string): void;
+  reorderSorts(fields: string[]): void;
+  clearAll(): void;
+  clearAllAndClose(): void;
+  addFirstAvailableSort(): void;
+  serializeToViewSorts(): ViewSort[];
+  applyViewSorts(viewSorts: ViewSort[]): void;
+  setOnChange(cb: (() => void) | null): void;
+  setOnApply(cb: ((sorts: ReturnType<SortModel['serializeToViewSorts']>) => void) | null): void;
+  dispose(): void;
+  private _fireOnApply;
+  private _notifyChange;
+}
+//#endregion
+//#region src/table-editor/Sortings/model/sortSchema.d.ts
+declare const SORT_SCHEMA: {
+  type: "array";
+  items: _revisium_schema_toolkit0.JsonSchema;
+  title?: string;
+  description?: string;
+  deprecated?: boolean;
+} & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+  readonly items: {
+    type: "object";
+    additionalProperties: false;
+    required: string[];
+    properties: Record<string, _revisium_schema_toolkit0.JsonSchema>;
+    title?: string;
+    description?: string;
+    deprecated?: boolean;
+  } & _revisium_schema_toolkit0.JsonSchemaSharedFields & {
+    readonly properties: {
+      readonly field: _revisium_schema_toolkit0.JsonStringSchema;
+      readonly direction: _revisium_schema_toolkit0.JsonStringSchema;
+    };
+  };
+};
+//#endregion
+//#region src/table-editor/Sortings/ui/SortingsWidget/SortingsWidget.d.ts
+interface SortingsWidgetProps {
+  model: SortModel;
+  availableFields: ColumnSpec[];
+  onChange: (sorts: ReturnType<SortModel['serializeToViewSorts']>) => void;
+}
+declare const SortingsWidget: (({
+  model,
+  availableFields,
+  onChange
+}: SortingsWidgetProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Sortings/ui/SortRow/SortRow.d.ts
+interface SortRowProps {
+  sort: SortEntry;
+  index: number;
+  model: SortModel;
+  availableFields: ColumnSpec[];
+}
+declare const SortRow: (({
+  sort,
+  index,
+  model,
+  availableFields
+}: SortRowProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Sortings/ui/SortFieldSelect/SortFieldSelect.d.ts
+interface SortFieldSelectProps {
+  currentField: string;
+  availableFields: ColumnSpec[];
+  onChange: (field: string) => void;
+}
+declare const SortFieldSelect: (({
+  currentField,
+  availableFields,
+  onChange
+}: SortFieldSelectProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Sortings/ui/SortDirectionSelect/SortDirectionSelect.d.ts
+interface SortDirectionSelectProps {
+  selectedDirection: 'asc' | 'desc';
+  onSelect: (direction: 'asc' | 'desc') => void;
+}
+declare const SortDirectionSelect: (({
+  selectedDirection,
+  onSelect
+}: SortDirectionSelectProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/model/SelectionModel.d.ts
+declare class SelectionModel {
+  private readonly _selected;
+  constructor();
+  get isSelectionMode(): boolean;
+  get selectedCount(): number;
+  get selectedIds(): string[];
+  isSelected(rowId: string): boolean;
+  deselect(rowId: string): void;
+  toggle(rowId: string): void;
+  selectAll(rowIds: string[]): void;
+  deselectAll(): void;
+  enterSelectionMode(rowId?: string): void;
+  isAllSelected(allRowIds: string[]): boolean;
+  exitSelectionMode(): void;
+}
+//#endregion
+//#region src/table-editor/Table/model/cellFSMConfig.d.ts
+interface CellAddress {
+  rowId: string;
+  field: string;
+}
+type EditTrigger = {
+  type: 'doubleClick';
+  clickOffset?: number;
+} | {
+  type: 'enter';
+} | {
+  type: 'char';
+  char: string;
+};
+interface SelectedRange {
+  startCol: number;
+  endCol: number;
+  startRow: number;
+  endRow: number;
+}
+interface SelectionEdges {
+  top: boolean;
+  bottom: boolean;
+  left: boolean;
+  right: boolean;
+}
+type CellState = 'idle' | 'focused' | 'editing';
+//#endregion
+//#region src/table-editor/Table/model/CellFSM.d.ts
+declare class CellFSM {
+  private readonly _fsm;
+  constructor();
+  get state(): CellState;
+  get focusedCell(): CellAddress | null;
+  get anchorCell(): CellAddress | null;
+  get editTrigger(): EditTrigger | null;
+  get columns(): string[];
+  get rowIds(): string[];
+  get navigationVersion(): number;
+  get hasSelection(): boolean;
+  isCellFocused(rowId: string, field: string): boolean;
+  isCellAnchor(rowId: string, field: string): boolean;
+  isCellEditing(rowId: string, field: string): boolean;
+  isCellInSelection(rowId: string, field: string): boolean;
+  getCellSelectionEdges(rowId: string, field: string): SelectionEdges | null;
+  private _getCellPosition;
+  getSelectedRange(): SelectedRange | null;
+  setNavigationContext(columns: string[], rowIds: string[]): void;
+  updateNavigationContext(columns: string[], rowIds: string[]): void;
+  focusCell(cell: CellAddress): void;
+  blur(): void;
+  doubleClick(clickOffset?: number): void;
+  enterEdit(): void;
+  typeChar(char: string): void;
+  commit(): void;
+  commitAndMoveDown(): void;
+  cancel(): void;
+  moveUp(): void;
+  moveDown(): void;
+  moveLeft(): void;
+  moveRight(): void;
+  handleTab(shift: boolean): void;
+  selectTo(cell: CellAddress): void;
+  shiftMoveUp(): void;
+  shiftMoveDown(): void;
+  shiftMoveLeft(): void;
+  shiftMoveRight(): void;
+  dragStart(cell: CellAddress): void;
+  dragExtend(cell: CellAddress): void;
+  dispose(): void;
+}
+//#endregion
+//#region src/table-editor/Table/model/CellVM.d.ts
+type CellCommitCallback = (rowId: string, field: string, value: unknown, previousValue?: unknown) => void;
+declare class CellVM {
+  private readonly _rowModel;
+  private readonly _column;
+  private readonly _rowId;
+  private readonly _cellFSM;
+  private readonly _onCommit;
+  constructor(rowModel: RowModel, column: ColumnSpec, rowId: string, cellFSM: CellFSM, onCommit?: CellCommitCallback);
+  get field(): string;
+  get jsonPath(): string;
+  get column(): ColumnSpec;
+  get rowId(): string;
+  get value(): unknown;
+  get displayValue(): string;
+  get isReadOnly(): boolean;
+  get foreignKeyTableId(): string | undefined;
+  get isEditable(): boolean;
+  get isFocused(): boolean;
+  get isEditing(): boolean;
+  get isAnchor(): boolean;
+  get isInSelection(): boolean;
+  get selectionEdges(): SelectionEdges | null;
+  get hasRangeSelection(): boolean;
+  get navigationVersion(): number;
+  get editTrigger(): EditTrigger | null;
+  focus(): void;
+  startEdit(): void;
+  startEditWithChar(char: string): void;
+  startEditWithDoubleClick(clickOffset?: number): void;
+  commitEdit(newValue: unknown): void;
+  commitEditAndMoveDown(newValue?: unknown): void;
+  cancelEdit(): void;
+  clearToDefault(): void;
+  copyToClipboard(): Promise<void>;
+  pasteFromClipboard(): Promise<void>;
+  applyPastedText(text: string): void;
+  blur(): void;
+  moveUp(): void;
+  moveDown(): void;
+  moveLeft(): void;
+  moveRight(): void;
+  handleTab(shift: boolean): void;
+  selectTo(): void;
+  shiftMoveUp(): void;
+  shiftMoveDown(): void;
+  shiftMoveLeft(): void;
+  shiftMoveRight(): void;
+  dragStart(): void;
+  dragExtend(): void;
+  private _getNode;
+  private _applyPastedString;
+  private _applyPastedNumber;
+  private _applyPastedBoolean;
+}
+//#endregion
+//#region src/table-editor/Table/model/RowVM.d.ts
+declare class RowVM {
+  private readonly _rowModel;
+  private readonly _rowId;
+  private readonly _cellFSM;
+  private readonly _selection;
+  private readonly _onCellCommit;
+  private readonly _cellCache;
+  constructor(rowModel: RowModel, rowId: string, cellFSM: CellFSM, selection: SelectionModel, onCellCommit?: CellCommitCallback);
+  get rowId(): string;
+  get rowModel(): RowModel;
+  get isSelected(): boolean;
+  toggleSelection(): void;
+  getCellVM(column: ColumnSpec): CellVM;
+  dispose(): void;
+}
+//#endregion
+//#region src/search-foreign-key/vm/SearchForeignKeyVM.d.ts
+type SearchForeignKeySearchFn = (tableId: string, search: string) => Promise<{
+  ids: string[];
+  hasMore: boolean;
+}>;
+type SearchState = 'loading' | 'empty' | 'list' | 'notFound' | 'error';
+declare class SearchForeignKeyVM {
+  private readonly _tableId;
+  private readonly _onSearch;
+  private _search;
+  private _state;
+  private _ids;
+  private _hasMore;
+  private _initialized;
+  private _disposeReaction;
+  private readonly _debounce;
+  constructor(_tableId: string, _onSearch: SearchForeignKeySearchFn | null);
+  get search(): string;
+  get state(): SearchState;
+  get ids(): string[];
+  get hasMore(): boolean;
+  get showInput(): boolean;
+  get showFooter(): boolean;
+  get showLoading(): boolean;
+  get showNotFound(): boolean;
+  get showError(): boolean;
+  get showEmpty(): boolean;
+  get showList(): boolean;
+  get tableId(): string;
+  init(): void;
+  setSearch(value: string): void;
+  dispose(): void;
+  private _debouncedSearch;
+  private _resolveState;
+  private _performSearch;
+}
+//#endregion
+//#region src/search-foreign-key/ui/SearchForeignKey.d.ts
+interface SearchForeignKeyProps {
+  tableId: string;
+  onSearch: SearchForeignKeySearchFn;
+  onSelect: (id: string) => void;
+  onClose?: () => void;
+  onOpenTableSearch?: () => void;
+  onCreateAndConnect?: () => void;
+}
+declare const SearchForeignKey: FC<SearchForeignKeyProps>;
+//#endregion
+//#region src/table-editor/Table/ui/Cell/CellRenderer.d.ts
+interface CellRendererProps {
+  cell: CellVM;
+  onSearchForeignKey?: SearchForeignKeySearchFn;
+}
+declare const CellRenderer: (({
+  cell,
+  onSearchForeignKey
+}: CellRendererProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/Cell/CellWrapper.d.ts
+interface CellWrapperProps extends PropsWithChildren {
+  cell: CellVM;
+  onDoubleClick?: (clientX?: number) => void;
+  onStartEdit?: () => void;
+  onTypeChar?: (char: string) => void;
+  onDelete?: () => void;
+}
+declare const CellWrapper: FC<CellWrapperProps>;
+//#endregion
+//#region src/table-editor/Table/ui/Cell/StringCell.d.ts
+interface StringCellProps {
+  cell: CellVM;
+}
+declare const StringCell: (({
+  cell
+}: StringCellProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/Cell/NumberCell.d.ts
+interface NumberCellProps {
+  cell: CellVM;
+}
+declare const NumberCell: (({
+  cell
+}: NumberCellProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/Cell/BooleanCell.d.ts
+interface BooleanCellProps {
+  cell: CellVM;
+}
+declare const BooleanCell: (({
+  cell
+}: BooleanCellProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/Cell/ForeignKeyCell.d.ts
+interface ForeignKeyCellProps {
+  cell: CellVM;
+  onSearchForeignKey?: SearchForeignKeySearchFn;
+}
+declare const ForeignKeyCell: (({
+  cell,
+  onSearchForeignKey
+}: ForeignKeyCellProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/Cell/FileCell.d.ts
+interface FileCellProps {
+  cell: CellVM;
+}
+declare const FileCell: (({
+  cell
+}: FileCellProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/Cell/DateTimeCell.d.ts
+interface DateTimeCellProps {
+  cell: CellVM;
+}
+declare const DateTimeCell: (({
+  cell
+}: DateTimeCellProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/Cell/ReadonlyCell.d.ts
+interface ReadonlyCellProps {
+  cell: CellVM;
+}
+declare const ReadonlyCell: (({
+  cell
+}: ReadonlyCellProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/TableWidget.d.ts
+interface TableWidgetProps {
+  rows: RowVM[];
+  columnsModel: ColumnsModel;
+  cellFSM?: CellFSM;
+  selection: SelectionModel;
+  sortModel?: SortModel;
+  filterModel?: FilterCore;
+  onSearchForeignKey?: SearchForeignKeySearchFn;
+  onOpenRow?: (rowId: string) => void;
+  onDeleteSelected?: (ids: string[]) => void;
+  onDuplicateSelected?: (ids: string[]) => void;
+  onDeleteRow?: (rowId: string) => void;
+  onDuplicateRow?: (rowId: string) => void;
+  onCopyPath?: (path: string) => void;
+  onEndReached?: () => void;
+  isLoadingMore?: boolean;
+  useWindowScroll?: boolean;
+}
+declare const TableWidget: (({
+  rows,
+  columnsModel,
+  cellFSM,
+  selection,
+  sortModel,
+  filterModel,
+  onSearchForeignKey,
+  onOpenRow,
+  onDeleteSelected,
+  onDuplicateSelected,
+  onDeleteRow,
+  onDuplicateRow,
+  onCopyPath,
+  onEndReached,
+  isLoadingMore,
+  useWindowScroll: useWindowScrollProp
+}: TableWidgetProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/HeaderRow.d.ts
+interface HeaderRowProps {
+  columnsModel: ColumnsModel;
+  sortModel?: SortModel;
+  filterModel?: FilterCore;
+  onCopyPath?: (path: string) => void;
+  showSelection?: boolean;
+  showLeftShadow?: boolean;
+  showRightShadow?: boolean;
+}
+declare const HeaderRow: (({
+  columnsModel,
+  sortModel,
+  filterModel,
+  onCopyPath,
+  showSelection,
+  showLeftShadow,
+  showRightShadow
+}: HeaderRowProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/DataRow.d.ts
+interface DataRowProps {
+  row: RowVM;
+  columnsModel: ColumnsModel;
+  showSelection: boolean;
+  showLeftShadow?: boolean;
+  showRightShadow?: boolean;
+  onSearchForeignKey?: SearchForeignKeySearchFn;
+  onOpenRow?: (rowId: string) => void;
+  onSelectRow?: (rowId: string) => void;
+  onDuplicateRow?: (rowId: string) => void;
+  onDeleteRow?: (rowId: string) => void;
+}
+declare const DataRow: (({
+  row,
+  columnsModel,
+  showSelection,
+  showLeftShadow,
+  showRightShadow,
+  onSearchForeignKey,
+  onOpenRow,
+  onSelectRow,
+  onDuplicateRow,
+  onDeleteRow
+}: DataRowProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/ResizeHandle.d.ts
+interface ResizeHandleProps {
+  field: string;
+  columnsModel: ColumnsModel;
+}
+declare const ResizeHandle: (({
+  field,
+  columnsModel
+}: ResizeHandleProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/SelectionToolbar.d.ts
+interface SelectionToolbarProps {
+  selection: SelectionModel;
+  allRowIds: string[];
+  onDuplicate?: (ids: string[]) => void;
+  onDelete?: (ids: string[]) => void;
+}
+declare const SelectionToolbar: (({
+  selection,
+  allRowIds,
+  onDuplicate,
+  onDelete
+}: SelectionToolbarProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Table/ui/RowActionsMenu/RowActionsMenu.d.ts
+interface RowActionsMenuProps {
+  rowId: string;
+  onSelect?: (rowId: string) => void;
+  onDuplicate?: (rowId: string) => void;
+  onDelete?: (rowId: string) => void;
+}
+declare const RowActionsMenu: FC<RowActionsMenuProps>;
+//#endregion
+//#region src/table-editor/Table/ui/DeleteConfirmDialog/DeleteConfirmDialog.d.ts
+interface DeleteConfirmDialogProps {
+  isOpen: boolean;
+  onClose: () => void;
+  onConfirm: () => void;
+  count?: number;
+}
+declare const DeleteConfirmDialog: FC<DeleteConfirmDialogProps>;
+//#endregion
+//#region src/table-editor/Status/model/RowCountModel.d.ts
+declare class RowCountModel {
+  private _totalCount;
+  private _baseTotalCount;
+  private _isFiltering;
+  private _isRefetching;
+  constructor();
+  get totalCount(): number;
+  get baseTotalCount(): number;
+  get isFiltering(): boolean;
+  get isRefetching(): boolean;
+  get text(): string;
+  setTotalCount(count: number): void;
+  setBaseTotalCount(count: number): void;
+  setIsFiltering(value: boolean): void;
+  setRefetching(value: boolean): void;
+  decrementBaseTotalCount(by?: number): void;
+}
+//#endregion
+//#region src/table-editor/Status/model/ViewSettingsBadgeModel.d.ts
+declare class ViewSettingsBadgeModel {
+  private _snapshot;
+  private _currentSnapshot;
+  private _canSave;
+  private _isPopoverOpen;
+  private _onSave;
+  private _onRevert;
+  constructor();
+  get hasChanges(): boolean;
+  get isVisible(): boolean;
+  get canSave(): boolean;
+  get isPopoverOpen(): boolean;
+  saveSnapshot(state: unknown): void;
+  checkForChanges(state: unknown): void;
+  save(): Promise<void>;
+  revert(): void;
+  setCanSave(value: boolean): void;
+  setPopoverOpen(value: boolean): void;
+  setOnSave(cb: (() => Promise<void>) | null): void;
+  setOnRevert(cb: (() => void) | null): void;
+  dispose(): void;
+}
+//#endregion
+//#region src/table-editor/TableEditor/model/ITableDataSource.d.ts
+interface RowDataItem {
+  rowId: string;
+  data: Record<string, unknown>;
+}
+interface TableMetadata {
+  schema: JsonSchema;
+  columns: ColumnSpec[];
+  viewState: ViewState | null;
+  readonly: boolean;
+}
+interface TableQuery {
+  where: Record<string, unknown> | null;
+  orderBy: Array<{
+    field: string;
+    direction: string;
+  }>;
+  search: string;
+  first: number;
+  after: string | null;
+}
+interface FetchRowsResult {
+  rows: RowDataItem[];
+  totalCount: number;
+  hasNextPage: boolean;
+  endCursor: string | null;
+}
+interface CellPatch {
+  rowId: string;
+  field: string;
+  value: unknown;
+}
+interface CellPatchResult {
+  rowId: string;
+  field: string;
+  ok: boolean;
+  error?: string;
+}
+interface DeleteRowsResult {
+  ok: boolean;
+  error?: string;
+}
+interface ITableDataSource {
+  fetchMetadata(): Promise<TableMetadata>;
+  fetchRows(query: TableQuery): Promise<FetchRowsResult>;
+  patchCells(patches: CellPatch[]): Promise<CellPatchResult[]>;
+  deleteRows(rowIds: string[]): Promise<DeleteRowsResult>;
+  saveView(viewState: ViewState): Promise<{
+    ok: boolean;
+    error?: string;
+  }>;
+}
+//#endregion
+//#region src/table-editor/TableEditor/model/TableEditorCore.d.ts
+interface ViewState {
+  columns: Array<{
+    field: string;
+    width?: number;
+  }>;
+  filters: string | null;
+  sorts: Array<{
+    field: string;
+    direction: string;
+  }>;
+  search: string;
+}
+interface TableEditorBreadcrumb {
+  label: string;
+  dataTestId?: string;
+}
+interface TableEditorCallbacks {
+  onBreadcrumbClick?: (segment: TableEditorBreadcrumb, index: number) => void;
+  onCreateRow?: () => void;
+  onOpenRow?: (rowId: string) => void;
+  onDuplicateRow?: (rowId: string) => void;
+  onSearchForeignKey?: SearchForeignKeySearchFn;
+  onCopyPath?: (path: string) => void;
+}
+interface TableEditorOptions {
+  tableId: string;
+  pageSize?: number;
+  breadcrumbs?: TableEditorBreadcrumb[];
+  callbacks?: TableEditorCallbacks;
+}
+declare class TableEditorCore {
+  readonly columns: ColumnsModel;
+  readonly filters: FilterCore;
+  readonly sorts: SortModel;
+  readonly search: SearchModel;
+  readonly viewBadge: ViewSettingsBadgeModel;
+  readonly cellFSM: CellFSM;
+  readonly selection: SelectionModel;
+  readonly rowCount: RowCountModel;
+  private readonly _dataSource;
+  private readonly _pageSize;
+  private readonly _breadcrumbs;
+  private readonly _callbacks;
+  private readonly _tableId;
+  private _schema;
+  private _readonly;
+  private _rows;
+  private _isBootstrapping;
+  private _isLoadingMore;
+  private _hasNextPage;
+  private _endCursor;
+  private _savedViewState;
+  constructor(dataSource: ITableDataSource, options: TableEditorOptions);
+  get rows(): RowVM[];
+  get isBootstrapping(): boolean;
+  get isLoadingMore(): boolean;
+  get readonly(): boolean;
+  get tableId(): string;
+  get breadcrumbs(): TableEditorBreadcrumb[];
+  get callbacks(): TableEditorCallbacks;
+  getViewState(): ViewState;
+  applyViewState(state: ViewState): void;
+  loadMore(): Promise<void>;
+  deleteRows(rowIds: string[]): Promise<void>;
+  dispose(): void;
+  private _bootstrap;
+  private _buildQuery;
+  private _loadRows;
+  private _reloadRows;
+  private _replaceRowVMs;
+  private _appendRowVMs;
+  private _createRowVMs;
+  private _commitCell;
+  private _updateNavigationContext;
+  private _handleColumnsChange;
+  private _handleFilterChange;
+  private _handleFilterApply;
+  private _handleSortChange;
+  private _handleSortApply;
+  private _handleSearch;
+  private _handleViewSave;
+  private _handleViewRevert;
+  private _saveViewSnapshot;
+  private _checkViewChanges;
+}
+//#endregion
+//#region src/table-editor/TableEditor/model/MockDataSource.d.ts
+interface MockDataSourceParams {
+  schema: JsonSchema;
+  columns: ColumnSpec[];
+  rows: RowDataItem[];
+  viewState?: ViewState | null;
+  readonly?: boolean;
+  failPatches?: Set<string>;
+}
+declare class MockDataSource implements ITableDataSource {
+  private _allRows;
+  private readonly _schema;
+  private readonly _columns;
+  private readonly _viewState;
+  private readonly _readonly;
+  private readonly _failPatches;
+  readonly fetchMetadataLog: Array<true>;
+  readonly fetchLog: TableQuery[];
+  readonly patchLog: CellPatch[][];
+  readonly deleteLog: string[][];
+  readonly saveViewLog: ViewState[];
+  constructor(params: MockDataSourceParams);
+  static createRow(rowId: string, data: Record<string, unknown>): RowDataItem;
+  fetchMetadata(): Promise<TableMetadata>;
+  fetchRows(query: TableQuery): Promise<FetchRowsResult>;
+  patchCells(patches: CellPatch[]): Promise<CellPatchResult[]>;
+  deleteRows(rowIds: string[]): Promise<DeleteRowsResult>;
+  saveView(viewState: ViewState): Promise<{
+    ok: boolean;
+  }>;
+}
+//#endregion
+//#region src/table-editor/TableEditor/ui/TableEditor.d.ts
+interface TableEditorProps {
+  viewModel: TableEditorCore;
+  useWindowScroll?: boolean;
+}
+declare const TableEditor: FC<TableEditorProps>;
+//#endregion
+//#region src/table-editor/Status/ui/RowCountWidget.d.ts
+interface RowCountWidgetProps {
+  model: RowCountModel;
+}
+declare const RowCountWidget: (({
+  model
+}: RowCountWidgetProps) => react_jsx_runtime19.JSX.Element) & {
+  displayName: string;
+};
+//#endregion
+//#region src/table-editor/Status/ui/ViewSettingsBadge.d.ts
+interface ViewSettingsBadgeProps {
+  model: ViewSettingsBadgeModel;
+}
+declare const ViewSettingsBadge: (({
+  model
+}: ViewSettingsBadgeProps) => react_jsx_runtime19.JSX.Element | null) & {
+  displayName: string;
+};
+//#endregion
 //#region src/components/Tooltip/Tooltip.d.ts
 interface TooltipProps extends Tooltip$1.RootProps {
   showArrow?: boolean;
@@ -822,6 +2201,30 @@ interface TooltipProps extends Tooltip$1.RootProps {
 }
 declare const Tooltip: React$1.ForwardRefExoticComponent<TooltipProps & React$1.RefAttributes<HTMLDivElement>>;
 //#endregion
+//#region src/components/Breadcrumbs/Breadcrumbs.d.ts
+interface BreadcrumbSegment {
+  label: string;
+  dataTestId?: string;
+}
+interface BreadcrumbEditableProps {
+  value: string;
+  onChange?: (value: string) => void;
+  onBlur?: (value: string) => void;
+  tooltip?: string;
+  placeholder?: string;
+  dataTestId?: string;
+}
+interface BreadcrumbsProps {
+  segments: BreadcrumbSegment[];
+  separator?: string;
+  dataTestId?: string;
+  highlightLast?: boolean;
+  onSegmentClick?: (segment: BreadcrumbSegment, index: number) => void;
+  editable?: BreadcrumbEditableProps;
+  action?: React.ReactNode;
+}
+declare const Breadcrumbs: React.FC<BreadcrumbsProps>;
+//#endregion
 //#region src/components/GrayButton/GrayButton.d.ts
 interface GrayButtonProps {
   title: string;
@@ -865,6 +2268,15 @@ interface CopyButtonProps extends IconButtonProps {
 }
 declare const CopyButton: FC<CopyButtonProps>;
 //#endregion
+//#region src/components/PlusButton/PlusButton.d.ts
+interface PlusButtonProps {
+  onClick?: () => void;
+  tooltip?: string;
+  disabled?: boolean;
+  dataTestId?: string;
+}
+declare const PlusButton: React.FC<PlusButtonProps>;
+//#endregion
 //#region src/components/JsonCard/JsonCard.d.ts
 type JsonValue = string | number | boolean | null | JsonValue[] | {
   [key: string]: JsonValue;
@@ -886,56 +2298,8 @@ interface ViewerSwitcherProps {
 }
 declare const ViewerSwitcher: React.FC<ViewerSwitcherProps>;
 //#endregion
-//#region src/search-foreign-key/vm/SearchForeignKeyVM.d.ts
-type SearchForeignKeySearchFn = (tableId: string, search: string) => Promise<{
-  ids: string[];
-  hasMore: boolean;
-}>;
-type SearchState = 'loading' | 'empty' | 'list' | 'notFound' | 'error';
-declare class SearchForeignKeyVM {
-  private readonly _tableId;
-  private readonly _onSearch;
-  private _search;
-  private _state;
-  private _ids;
-  private _hasMore;
-  private _initialized;
-  private _disposeReaction;
-  private readonly _debounce;
-  constructor(_tableId: string, _onSearch: SearchForeignKeySearchFn | null);
-  get search(): string;
-  get state(): SearchState;
-  get ids(): string[];
-  get hasMore(): boolean;
-  get showInput(): boolean;
-  get showFooter(): boolean;
-  get showLoading(): boolean;
-  get showNotFound(): boolean;
-  get showError(): boolean;
-  get showEmpty(): boolean;
-  get showList(): boolean;
-  get tableId(): string;
-  init(): void;
-  setSearch(value: string): void;
-  dispose(): void;
-  private _debouncedSearch;
-  private _resolveState;
-  private _performSearch;
-}
-//#endregion
-//#region src/search-foreign-key/ui/SearchForeignKey.d.ts
-interface SearchForeignKeyProps {
-  tableId: string;
-  onSearch: SearchForeignKeySearchFn;
-  onSelect: (id: string) => void;
-  onClose?: () => void;
-  onOpenTableSearch?: () => void;
-  onCreateAndConnect?: () => void;
-}
-declare const SearchForeignKey: FC<SearchForeignKeyProps>;
-//#endregion
 //#region src/lib/initReactivity.d.ts
 declare function ensureReactivityProvider(): void;
 //#endregion
-export { type ArrayNodeVM, BackButton, CloseButton, ContentEditable, type ContentEditableProps, CopyButton, CreateButton, CreatingEditorVM, type CreatingEditorVMOptions, CreatingSchemaEditor, type CreatingSchemaEditorProps, type FileNodeVM, type FileUploadResult, type FlatItem, type ForeignKeyNodeVM, type ForeignKeySearchResult, type ForeignKeySelectionCallback, GrayButton, JsonCard, type MenuGroup, type MenuOptionItem, type NodeVM, type ObjectNodeVM, type PrimitiveNodeVM, RowEditor, type RowEditorCallbacks, type RowEditorMode, type RowEditorProps, RowEditorVM, type RowEditorVMOptions, SchemaEditorCore, type SchemaEditorCoreOptions, SchemaTypeIds, SearchForeignKey, type SearchForeignKeyProps, type SearchForeignKeySearchFn, SearchForeignKeyVM, SettingsButton, Tooltip, type TooltipProps, UpdatingEditorVM, type UpdatingEditorVMOptions, UpdatingSchemaEditor, type UpdatingSchemaEditorProps, type UseContentEditableOptions, type UseContentEditableReturn, type ViewMode, ViewerSwitcher, ViewerSwitcherMode, ensureReactivityProvider, getLabelByRef, typeMenuGroups, useContentEditable };
+export { type ArrayNodeVM, BackButton, BooleanCell, type BreadcrumbEditableProps, type BreadcrumbSegment, Breadcrumbs, type BreadcrumbsProps, type CellAddress, type CellCommitCallback, CellFSM, type CellPatch, type CellPatchResult, CellRenderer, CellVM, CellWrapper, CloseButton, type ColumnSpec, ColumnsModel, ContentEditable, type ContentEditableProps, CopyButton, CreateButton, CreatingEditorVM, type CreatingEditorVMOptions, CreatingSchemaEditor, type CreatingSchemaEditorProps, DataRow, DateTimeCell, DeleteConfirmDialog, type DeleteRowsResult, type EditTrigger, type FetchRowsResult, FieldSelect, FileCell, type FileNodeVM, type FileUploadResult, type FilterCondition, FilterConditionVM, FilterConditionView, FilterCore, FilterCore as FilterModel, FilterFieldType, type FilterGroup, FilterGroupVM, FilterGroupView, FilterOperator, FilterValueInput, FilterWidget, type FlatItem, ForeignKeyCell, type ForeignKeyNodeVM, type ForeignKeySearchResult, type ForeignKeySelectionCallback, GrayButton, HeaderRow, type ITableDataSource, JsonCard, type MenuGroup, type MenuOptionItem, MockDataSource, type NodeVM, NumberCell, OPERATORS_BY_TYPE, type ObjectNodeVM, type OperatorInfo, OperatorSelect, PlusButton, type PlusButtonProps, type PrimitiveNodeVM, ReadonlyCell, ResizeHandle, RowActionsMenu, RowCountModel, RowCountWidget, type RowDataItem, RowEditor, type RowEditorCallbacks, type RowEditorMode, type RowEditorProps, RowEditorVM, type RowEditorVMOptions, RowVM, SEARCH_LANGUAGES, SEARCH_TYPES, SORT_SCHEMA, SYSTEM_FIELDS, SYSTEM_FIELD_BY_REF, SYSTEM_FIELD_IDS, SchemaEditorCore, type SchemaEditorCoreOptions, SchemaTypeIds, SearchForeignKey, type SearchForeignKeyProps, type SearchForeignKeySearchFn, SearchForeignKeyVM, SearchLanguage, SearchModel, SearchType, SearchWidget, SelectionModel, SelectionToolbar, SettingsButton, SortDirectionSelect, type SortEntry, SortFieldSelect, SortModel, SortRow, SortingsWidget, StringCell, type SystemFieldDef, SystemFieldId, TableEditor, type TableEditorBreadcrumb, type TableEditorCallbacks, TableEditorCore, type TableEditorOptions, type TableEditorProps, type TableMetadata, type TableQuery, TableWidget, Tooltip, type TooltipProps, UpdatingEditorVM, type UpdatingEditorVMOptions, UpdatingSchemaEditor, type UpdatingSchemaEditorProps, type UseContentEditableOptions, type UseContentEditableReturn, type ViewColumn, type ViewMode, ViewSettingsBadge, ViewSettingsBadgeModel, type ViewSort, type ViewState, ViewerSwitcher, ViewerSwitcherMode, buildWhereClause, ensureReactivityProvider, extractColumns, getDefaultOperator, getLabelByRef, getOperatorLabel, getOperatorsForType, operatorRequiresValue, selectDefaultColumns, typeMenuGroups, useContentEditable };
 //# sourceMappingURL=index.d.mts.map