@oneflowui/ui 0.8.1 → 0.8.3

package/dist/components/database/DatabaseViewContent.vue.d.ts

@@ -0,0 +1,74 @@
+import { DataRecord, TableColumn, TableSchema, ViewConfig } from '../../types';
+type __VLS_Props = {
+    viewType: ViewConfig["viewType"];
+    records: DataRecord[];
+    schema?: TableSchema | null;
+    view: ViewConfig;
+    columns: TableColumn[];
+    readonly?: boolean;
+    enableFieldManagement?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    add: () => any;
+    "row-click": (payload: unknown) => any;
+    "cell-edit": (payload: {
+        rowId: string;
+        fieldId: string;
+        value: unknown;
+    }) => any;
+    "row-click-record": (record: DataRecord) => any;
+    "schema-add-field": (fieldType: string) => any;
+    "schema-rename-field": (payload: {
+        fieldId: string;
+        newName: string;
+    }) => any;
+    "schema-change-field-type": (payload: {
+        fieldId: string;
+        newType: string;
+    }) => any;
+    "schema-hide-field": (fieldId: string) => any;
+    "schema-delete-field": (fieldId: string) => any;
+    "schema-duplicate-field": (fieldId: string) => any;
+    "card-click": (payload: unknown) => any;
+    "add-column": () => any;
+    "record-change": (payload: {
+        recordId: string;
+        startDate?: string;
+        endDate?: string;
+    }) => any;
+    "update:records": (records: DataRecord[]) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onAdd?: (() => any) | undefined;
+    "onRow-click"?: ((payload: unknown) => any) | undefined;
+    "onCell-edit"?: ((payload: {
+        rowId: string;
+        fieldId: string;
+        value: unknown;
+    }) => any) | undefined;
+    "onRow-click-record"?: ((record: DataRecord) => any) | undefined;
+    "onSchema-add-field"?: ((fieldType: string) => any) | undefined;
+    "onSchema-rename-field"?: ((payload: {
+        fieldId: string;
+        newName: string;
+    }) => any) | undefined;
+    "onSchema-change-field-type"?: ((payload: {
+        fieldId: string;
+        newType: string;
+    }) => any) | undefined;
+    "onSchema-hide-field"?: ((fieldId: string) => any) | undefined;
+    "onSchema-delete-field"?: ((fieldId: string) => any) | undefined;
+    "onSchema-duplicate-field"?: ((fieldId: string) => any) | undefined;
+    "onCard-click"?: ((payload: unknown) => any) | undefined;
+    "onAdd-column"?: (() => any) | undefined;
+    "onRecord-change"?: ((payload: {
+        recordId: string;
+        startDate?: string;
+        endDate?: string;
+    }) => any) | undefined;
+    "onUpdate:records"?: ((records: DataRecord[]) => any) | undefined;
+}>, {
+    readonly: boolean;
+    schema: TableSchema | null;
+    enableFieldManagement: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/database/DatabaseViewContent.vue.js

@@ -0,0 +1,79 @@
+import { defineComponent as t, openBlock as o, createElementBlock as n, createBlock as l } from "vue";
+import m from "../table/DataTable.vue.js";
+import w from "../kanban/KanbanBoard.vue.js";
+import c from "../gallery/GalleryView.vue.js";
+import v from "../timeline/GanttTimeline.vue.js";
+const f = ["data-view"], p = {
+  key: 4,
+  class: "of-database-view__detail-anchor"
+}, h = /* @__PURE__ */ t({
+  name: "DatabaseViewContent",
+  __name: "DatabaseViewContent",
+  props: {
+    viewType: {},
+    records: {},
+    schema: { default: null },
+    view: {},
+    columns: {},
+    readonly: { type: Boolean, default: !1 },
+    enableFieldManagement: { type: Boolean, default: !1 }
+  },
+  emits: ["cell-edit", "schema-add-field", "schema-rename-field", "schema-change-field-type", "schema-hide-field", "schema-delete-field", "schema-duplicate-field", "row-click", "row-click-record", "card-click", "add", "add-column", "record-change", "update:records"],
+  setup(s, { emit: r }) {
+    const i = s, d = r;
+    return (u, e) => (o(), n("div", {
+      class: "of-database-view__content",
+      "data-view": i.viewType
+    }, [
+      i.viewType === "table" ? (o(), l(m, {
+        key: 0,
+        class: "of-database-view__view of-database-view__view--table",
+        records: i.records,
+        schema: i.schema ?? void 0,
+        view: i.view,
+        columns: i.columns,
+        readonly: i.readonly,
+        "enable-field-management": i.enableFieldManagement,
+        onCellEdit: e[0] || (e[0] = (a) => d("cell-edit", a)),
+        onSchemaAddField: e[1] || (e[1] = (a) => d("schema-add-field", a)),
+        onSchemaRenameField: e[2] || (e[2] = (a) => d("schema-rename-field", a)),
+        onSchemaChangeFieldType: e[3] || (e[3] = (a) => d("schema-change-field-type", a)),
+        onSchemaHideField: e[4] || (e[4] = (a) => d("schema-hide-field", a)),
+        onSchemaDeleteField: e[5] || (e[5] = (a) => d("schema-delete-field", a)),
+        onSchemaDuplicateField: e[6] || (e[6] = (a) => d("schema-duplicate-field", a)),
+        onRowClick: e[7] || (e[7] = (a) => d("row-click", a)),
+        onRowClickRecord: e[8] || (e[8] = (a) => d("row-click-record", a))
+      }, null, 8, ["records", "schema", "view", "columns", "readonly", "enable-field-management"])) : i.viewType === "kanban" ? (o(), l(w, {
+        key: 1,
+        class: "of-database-view__view of-database-view__view--kanban",
+        records: i.records,
+        schema: i.schema ?? void 0,
+        view: i.view,
+        onCardClick: e[9] || (e[9] = (a) => d("card-click", a)),
+        "onUpdate:columns": e[10] || (e[10] = () => {
+        }),
+        onAddColumn: e[11] || (e[11] = (a) => d("add-column"))
+      }, null, 8, ["records", "schema", "view"])) : i.viewType === "gallery" ? (o(), l(c, {
+        key: 2,
+        class: "of-database-view__view of-database-view__view--gallery",
+        records: i.records,
+        schema: i.schema ?? void 0,
+        view: i.view,
+        onCardClick: e[12] || (e[12] = (a) => d("card-click", a)),
+        onAdd: e[13] || (e[13] = (a) => d("add"))
+      }, null, 8, ["records", "schema", "view"])) : i.viewType === "timeline" ? (o(), l(v, {
+        key: 3,
+        class: "of-database-view__view of-database-view__view--timeline",
+        records: i.records,
+        schema: i.schema ?? void 0,
+        "view-config": i.view,
+        onRowClick: e[14] || (e[14] = (a) => d("row-click", a)),
+        onRecordChange: e[15] || (e[15] = (a) => d("record-change", a)),
+        "onUpdate:records": e[16] || (e[16] = (a) => d("update:records", a))
+      }, null, 8, ["records", "schema", "view-config"])) : (o(), n("div", p))
+    ], 8, f));
+  }
+});
+export {
+  h as default
+};

package/dist/components/database/DatabaseViewContent.vue2.js

@@ -0,0 +1,4 @@
+import f from "./DatabaseViewContent.vue.js";
+export {
+  f as default
+};

package/dist/components/database/DatabaseViewDetailHost.vue.d.ts

@@ -0,0 +1,43 @@
+import { DatabaseViewResolvedDetailPresentation } from '../../contracts/database';
+import { DatabaseDetailPropertyItem, DatabaseWorkspaceModeOption } from './databaseViewUtils';
+type __VLS_Props = {
+    visible: boolean;
+    title: string;
+    rowId: string;
+    recordId?: string;
+    viewType: string;
+    description: string;
+    presentation: DatabaseViewResolvedDetailPresentation;
+    sidePanelWidth: number;
+    drawerWidth: number;
+    canSwitchPresentation?: boolean;
+    workspaceModes?: DatabaseWorkspaceModeOption[];
+    propertyItems?: DatabaseDetailPropertyItem[];
+    readonly?: boolean;
+    hasDraftChanges?: boolean;
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    delete: (rowId: string) => any;
+    close: () => any;
+    save: () => any;
+    commit: (rowId: string, fieldId: string, value: unknown) => any;
+    "update:presentation": (value: DatabaseViewResolvedDetailPresentation) => any;
+    "update:side-panel-width": (width: number) => any;
+    "update:drawer-width": (width: number) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDelete?: ((rowId: string) => any) | undefined;
+    onClose?: (() => any) | undefined;
+    onSave?: (() => any) | undefined;
+    onCommit?: ((rowId: string, fieldId: string, value: unknown) => any) | undefined;
+    "onUpdate:presentation"?: ((value: DatabaseViewResolvedDetailPresentation) => any) | undefined;
+    "onUpdate:side-panel-width"?: ((width: number) => any) | undefined;
+    "onUpdate:drawer-width"?: ((width: number) => any) | undefined;
+}>, {
+    readonly: boolean;
+    recordId: string;
+    canSwitchPresentation: boolean;
+    workspaceModes: DatabaseWorkspaceModeOption[];
+    propertyItems: DatabaseDetailPropertyItem[];
+    hasDraftChanges: boolean;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/components/database/DatabaseViewDetailHost.vue.js

@@ -0,0 +1,59 @@
+import { defineComponent as l, openBlock as w, createBlock as m, createCommentVNode as f } from "vue";
+import u from "./DatabaseDetailPresenter.vue.js";
+const y = /* @__PURE__ */ l({
+  name: "DatabaseViewDetailHost",
+  __name: "DatabaseViewDetailHost",
+  props: {
+    visible: { type: Boolean },
+    title: {},
+    rowId: {},
+    recordId: { default: "" },
+    viewType: {},
+    description: {},
+    presentation: {},
+    sidePanelWidth: {},
+    drawerWidth: {},
+    canSwitchPresentation: { type: Boolean, default: !1 },
+    workspaceModes: { default: () => [] },
+    propertyItems: { default: () => [] },
+    readonly: { type: Boolean, default: !1 },
+    hasDraftChanges: { type: Boolean, default: !1 }
+  },
+  emits: ["commit", "save", "delete", "close", "update:side-panel-width", "update:drawer-width", "update:presentation"],
+  setup(n, { emit: r }) {
+    const e = n, i = r;
+    function d(o) {
+      if (e.presentation === "side-panel") {
+        i("update:side-panel-width", o);
+        return;
+      }
+      i("update:drawer-width", o);
+    }
+    return (o, t) => e.visible ? (w(), m(u, {
+      key: 0,
+      visible: e.visible,
+      title: e.title,
+      "row-id": e.rowId,
+      "record-id": e.recordId,
+      "view-type": e.viewType,
+      description: e.description,
+      presentation: e.presentation,
+      "side-panel-width": e.sidePanelWidth,
+      "drawer-width": e.drawerWidth,
+      "can-switch-presentation": e.canSwitchPresentation,
+      "workspace-modes": e.workspaceModes,
+      "property-items": e.propertyItems,
+      readonly: e.readonly,
+      "has-draft-changes": e.hasDraftChanges,
+      onCommit: t[0] || (t[0] = (a, s, p) => i("commit", a, s, p)),
+      onSave: t[1] || (t[1] = (a) => i("save")),
+      onDelete: t[2] || (t[2] = (a) => i("delete", a)),
+      onClose: t[3] || (t[3] = (a) => i("close")),
+      "onUpdate:width": d,
+      "onUpdate:presentation": t[4] || (t[4] = (a) => i("update:presentation", a))
+    }, null, 8, ["visible", "title", "row-id", "record-id", "view-type", "description", "presentation", "side-panel-width", "drawer-width", "can-switch-presentation", "workspace-modes", "property-items", "readonly", "has-draft-changes"])) : f("", !0);
+  }
+});
+export {
+  y as default
+};

package/dist/components/database/DatabaseViewDetailHost.vue2.js

@@ -0,0 +1,4 @@
+import f from "./DatabaseViewDetailHost.vue.js";
+export {
+  f as default
+};

package/dist/components/database/DatabaseViewShell.vue.d.ts

@@ -0,0 +1,35 @@
+import { Component } from 'vue';
+import { EmptyStateAction } from '../base/EmptyState.vue';
+type __VLS_Props = {
+    state: "loading" | "error" | "empty" | "normal";
+    loadingTitle: string;
+    loadingDescription: string;
+    errorTitle: string;
+    errorDescription: string;
+    errorIcon: Component;
+    emptyIcon: Component;
+    emptyTitle: string;
+    emptyDescription: string;
+    emptyAction?: EmptyStateAction;
+};
+declare function __VLS_template(): {
+    attrs: Partial<{}>;
+    slots: {
+        toolbar?(_: {}): any;
+        content?(_: {}): any;
+        detail?(_: {}): any;
+    };
+    refs: {};
+    rootEl: any;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {
+    emptyAction: EmptyStateAction;
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/components/database/DatabaseViewShell.vue.js

@@ -0,0 +1,7 @@
+import e from "./DatabaseViewShell.vue2.js";
+/* empty css                       */
+import a from "../../_virtual/_plugin-vue_export-helper.js";
+const f = /* @__PURE__ */ a(e, [["__scopeId", "data-v-8eae2f2e"]]);
+export {
+  f as default
+};

package/dist/components/database/DatabaseViewShell.vue2.js

@@ -0,0 +1,71 @@
+import { defineComponent as c, openBlock as t, createElementBlock as a, mergeProps as p, createVNode as i, unref as _, createElementVNode as s, toDisplayString as n, Fragment as m, renderSlot as r } from "vue";
+import { Loader2 as v } from "lucide-vue-next";
+import d from "../base/EmptyState.vue.js";
+const f = {
+  key: 0,
+  class: "of-database-view__state of-database-view__state--loading",
+  "data-role": "loading-state"
+}, y = { class: "of-database-view__state-text" }, b = { class: "of-database-view__state-title" }, w = { class: "of-database-view__state-description" }, u = {
+  key: 1,
+  class: "of-database-view__state",
+  "data-role": "error-state"
+}, h = {
+  key: 0,
+  class: "of-database-view__state of-database-view__state--empty",
+  "data-role": "empty-state"
+}, S = /* @__PURE__ */ c({
+  name: "DatabaseViewShell",
+  inheritAttrs: !1,
+  __name: "DatabaseViewShell",
+  props: {
+    state: {},
+    loadingTitle: {},
+    loadingDescription: {},
+    errorTitle: {},
+    errorDescription: {},
+    errorIcon: {},
+    emptyIcon: {},
+    emptyTitle: {},
+    emptyDescription: {},
+    emptyAction: { default: void 0 }
+  },
+  setup(l) {
+    const e = l;
+    return (o, g) => (t(), a("section", p({
+      class: "of-database-view",
+      "data-role": "database-view"
+    }, o.$attrs), [
+      e.state === "loading" ? (t(), a("div", f, [
+        i(_(v), {
+          class: "of-database-view__spinner",
+          size: 20,
+          "aria-hidden": "true"
+        }),
+        s("div", y, [
+          s("div", b, n(e.loadingTitle), 1),
+          s("div", w, n(e.loadingDescription), 1)
+        ])
+      ])) : e.state === "error" ? (t(), a("div", u, [
+        i(d, {
+          icon: e.errorIcon,
+          title: e.errorTitle,
+          description: e.errorDescription
+        }, null, 8, ["icon", "title", "description"])
+      ])) : (t(), a(m, { key: 2 }, [
+        r(o.$slots, "toolbar", {}, void 0, !0),
+        e.state === "empty" ? (t(), a("div", h, [
+          i(d, {
+            icon: e.emptyIcon,
+            title: e.emptyTitle,
+            description: e.emptyDescription,
+            action: e.emptyAction
+          }, null, 8, ["icon", "title", "description", "action"])
+        ])) : r(o.$slots, "content", { key: 1 }, void 0, !0)
+      ], 64)),
+      r(o.$slots, "detail", {}, void 0, !0)
+    ], 16));
+  }
+});
+export {
+  S as default
+};

package/dist/components/database/DatabaseViewToolbar.vue.d.ts

@@ -0,0 +1,77 @@
+import { TableColumn } from '../../types';
+import { FilterCondition, FilterLogic } from '../../composables/useTableFilter';
+import { ViewSwitcherTab } from '../table/TableToolbar.vue';
+type __VLS_Props = {
+    currentView?: string;
+    viewTabs?: ViewSwitcherTab[];
+    columns: TableColumn[];
+    filterConditions?: readonly FilterCondition[];
+    filterLogic?: FilterLogic;
+    filterActive?: boolean;
+    currentSort?: {
+        field: string | null;
+        order: "asc" | "desc" | null;
+    };
+    currentGroup?: string;
+    searchKeyword?: string;
+    showViewSwitch?: boolean;
+    showFilter?: boolean;
+    showSort?: boolean;
+    showGroup?: boolean;
+    showColumns?: boolean;
+    showSearch?: boolean;
+    savedViews?: {
+        id: string;
+        name: string;
+    }[];
+};
+declare const _default: import('vue').DefineComponent<__VLS_Props, {}, {}, {}, {}, import('vue').ComponentOptionsMixin, import('vue').ComponentOptionsMixin, {
+    sort: (field: string) => any;
+    group: (field: string | null) => any;
+    "update:columns": (columns: TableColumn[]) => any;
+    "update:currentView": (view: string) => any;
+    "update:searchKeyword": (keyword: string) => any;
+    "add-filter": () => any;
+    "remove-filter": (id: string) => any;
+    "update-filter": (id: string, update: Partial<FilterCondition>) => any;
+    "clear-filters": () => any;
+    "update:filterLogic": (logic: FilterLogic) => any;
+    "save-view": (name: string) => any;
+    "load-view": (viewId: string) => any;
+}, string, import('vue').PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onSort?: ((field: string) => any) | undefined;
+    onGroup?: ((field: string | null) => any) | undefined;
+    "onUpdate:columns"?: ((columns: TableColumn[]) => any) | undefined;
+    "onUpdate:currentView"?: ((view: string) => any) | undefined;
+    "onUpdate:searchKeyword"?: ((keyword: string) => any) | undefined;
+    "onAdd-filter"?: (() => any) | undefined;
+    "onRemove-filter"?: ((id: string) => any) | undefined;
+    "onUpdate-filter"?: ((id: string, update: Partial<FilterCondition>) => any) | undefined;
+    "onClear-filters"?: (() => any) | undefined;
+    "onUpdate:filterLogic"?: ((logic: FilterLogic) => any) | undefined;
+    "onSave-view"?: ((name: string) => any) | undefined;
+    "onLoad-view"?: ((viewId: string) => any) | undefined;
+}>, {
+    showFilter: boolean;
+    showGroup: boolean;
+    showSort: boolean;
+    showSearch: boolean;
+    currentView: string;
+    viewTabs: ViewSwitcherTab[];
+    filterConditions: readonly FilterCondition[];
+    filterLogic: FilterLogic;
+    filterActive: boolean;
+    currentSort: {
+        field: string | null;
+        order: "asc" | "desc" | null;
+    };
+    currentGroup: string;
+    searchKeyword: string;
+    showViewSwitch: boolean;
+    showColumns: boolean;
+    savedViews: {
+        id: string;
+        name: string;
+    }[];
+}, {}, {}, {}, string, import('vue').ComponentProvideOptions, false, {}, HTMLDivElement>;
+export default _default;

package/dist/components/database/DatabaseViewToolbar.vue.js

@@ -0,0 +1,62 @@
+import { defineComponent as u, openBlock as a, createBlock as n } from "vue";
+import d from "../table/TableToolbar.vue.js";
+const v = /* @__PURE__ */ u({
+  name: "DatabaseViewToolbar",
+  __name: "DatabaseViewToolbar",
+  props: {
+    currentView: { default: "table" },
+    viewTabs: { default: void 0 },
+    columns: {},
+    filterConditions: { default: void 0 },
+    filterLogic: { default: "and" },
+    filterActive: { type: Boolean, default: !1 },
+    currentSort: { default: void 0 },
+    currentGroup: { default: void 0 },
+    searchKeyword: { default: "" },
+    showViewSwitch: { type: Boolean, default: !0 },
+    showFilter: { type: Boolean, default: !0 },
+    showSort: { type: Boolean, default: !0 },
+    showGroup: { type: Boolean, default: !0 },
+    showColumns: { type: Boolean, default: !0 },
+    showSearch: { type: Boolean, default: !0 },
+    savedViews: { default: void 0 }
+  },
+  emits: ["update:currentView", "update:columns", "update:searchKeyword", "add-filter", "remove-filter", "update-filter", "clear-filters", "update:filterLogic", "sort", "group", "save-view", "load-view"],
+  setup(i, { emit: s }) {
+    const t = i, r = s;
+    return (w, e) => (a(), n(d, {
+      class: "of-database-view__toolbar",
+      "current-view": t.currentView,
+      "view-tabs": t.viewTabs,
+      columns: t.columns,
+      "filter-conditions": t.filterConditions,
+      "filter-logic": t.filterLogic,
+      "filter-active": t.filterActive,
+      "current-sort": t.currentSort,
+      "current-group": t.currentGroup,
+      "search-keyword": t.searchKeyword,
+      "show-view-switch": t.showViewSwitch,
+      "show-filter": t.showFilter,
+      "show-sort": t.showSort,
+      "show-group": t.showGroup,
+      "show-columns": t.showColumns,
+      "show-search": t.showSearch,
+      "saved-views": t.savedViews,
+      "onUpdate:currentView": e[0] || (e[0] = (o) => r("update:currentView", o)),
+      "onUpdate:columns": e[1] || (e[1] = (o) => r("update:columns", o)),
+      "onUpdate:searchKeyword": e[2] || (e[2] = (o) => r("update:searchKeyword", o)),
+      onAddFilter: e[3] || (e[3] = (o) => r("add-filter")),
+      onRemoveFilter: e[4] || (e[4] = (o) => r("remove-filter", o)),
+      onUpdateFilter: e[5] || (e[5] = (o, l) => r("update-filter", o, l)),
+      onClearFilters: e[6] || (e[6] = (o) => r("clear-filters")),
+      "onUpdate:filterLogic": e[7] || (e[7] = (o) => r("update:filterLogic", o)),
+      onSort: e[8] || (e[8] = (o) => r("sort", o)),
+      onGroup: e[9] || (e[9] = (o) => r("group", o)),
+      onSaveView: e[10] || (e[10] = (o) => r("save-view", o)),
+      onLoadView: e[11] || (e[11] = (o) => r("load-view", o))
+    }, null, 8, ["current-view", "view-tabs", "columns", "filter-conditions", "filter-logic", "filter-active", "current-sort", "current-group", "search-keyword", "show-view-switch", "show-filter", "show-sort", "show-group", "show-columns", "show-search", "saved-views"]));
+  }
+});
+export {
+  v as default
+};

package/dist/components/database/DatabaseViewToolbar.vue2.js

@@ -0,0 +1,4 @@
+import f from "./DatabaseViewToolbar.vue.js";
+export {
+  f as default
+};

package/dist/components/database/databaseViewUtils.d.ts

@@ -0,0 +1,91 @@
+import { FieldDef as CellFieldDef } from '../table/FieldCell.vue';
+import { DatabaseViewDetailPresentation, DatabaseViewResolvedDetailPresentation, DatabaseViewViewTab } from '../../contracts/database';
+import { FilterCondition as ToolbarFilterCondition, FilterLogic } from '../../composables/useTableFilter';
+import { CellValue, DataRecord, FieldDef as SchemaFieldDef, TableColumn, TableSchema, ViewConfig } from '../../types';
+export interface DatabaseViewListItem {
+    id: string;
+    name: string;
+    type: ViewConfig["viewType"];
+}
+export interface DatabaseViewCurrentSort {
+    field: string | null;
+    order: "asc" | "desc" | null;
+}
+export interface DatabaseWorkspaceModeOption {
+    value: DatabaseViewResolvedDetailPresentation;
+    label: string;
+}
+export interface DatabaseDetailPropertyItem {
+    key: string;
+    label: string;
+    field: CellFieldDef | null;
+    value: CellValue | undefined;
+    fallbackText: string;
+}
+export declare function cloneView(view: ViewConfig): ViewConfig;
+export declare function inferFieldIdsFromRecords(records: DataRecord[]): string[];
+export declare function getViewTypeIcon(viewType: ViewConfig["viewType"]): string;
+export declare function buildDatabaseViewTabs(options: {
+    providedTabs?: DatabaseViewViewTab[];
+    viewList: DatabaseViewListItem[];
+    detailViewId: string;
+}): DatabaseViewViewTab[];
+export declare function getVisibleFieldIds(schema?: TableSchema | null, records?: DataRecord[]): string[];
+export declare function buildFallbackView(schema?: TableSchema | null, records?: DataRecord[]): ViewConfig;
+export declare function buildVirtualDetailView(detailViewId: string, schema?: TableSchema | null, records?: DataRecord[]): ViewConfig;
+export declare function getFieldLabel(fieldId: string, schema?: TableSchema | null): string;
+export declare function resolveColumnType(field?: SchemaFieldDef): TableColumn["type"];
+export declare function resolveCellFieldType(field?: SchemaFieldDef): CellFieldDef["type"];
+export declare function buildTableColumns(view: ViewConfig, schema?: TableSchema | null, records?: DataRecord[]): {
+    key: string;
+    label: string;
+    type: "string" | "number" | "date" | "status" | "priority" | undefined;
+    hidden: boolean;
+    width: number | undefined;
+}[];
+export declare function buildDetailColumns(schema?: TableSchema | null, records?: DataRecord[]): {
+    key: string;
+    label: string;
+    type: "string" | "number" | "date" | "status" | "priority" | undefined;
+    hidden: boolean;
+    width: number | undefined;
+}[];
+export declare function buildDetailFieldDefs(schema?: TableSchema | null, records?: DataRecord[]): {
+    id: string;
+    type: import('../table').FieldType;
+    label: string;
+}[];
+export declare function normalizeCellValue(value: CellValue | undefined): string;
+export declare function compareCellValues(a: CellValue | undefined, b: CellValue | undefined): number;
+export declare function evaluateFilterCondition(value: CellValue | undefined, condition: ToolbarFilterCondition): boolean;
+export declare function buildEmptyFilter(fieldId: string): ToolbarFilterCondition;
+export declare function convertViewFiltersToToolbarFilters(filters?: ViewConfig["filters"]): ToolbarFilterCondition[];
+export declare function convertToolbarFiltersToViewFilters(filters: ToolbarFilterCondition[]): NonNullable<ViewConfig["filters"]>;
+export declare function toDetailRow(record: DataRecord | null): Record<string, unknown> & {
+    id: string;
+};
+export declare function buildRenderedRecords(options: {
+    records: DataRecord[];
+    searchKeyword: string;
+    visibleFieldIds: string[];
+    filterConditions: ToolbarFilterCondition[];
+    filterLogic: FilterLogic;
+    sort: DatabaseViewCurrentSort;
+}): DataRecord[];
+export declare function buildDetailWorkspaceTitle(record: DataRecord | null): string;
+export declare function partitionDetailColumns(columns: TableColumn[], fieldDefs: CellFieldDef[]): {
+    propertyColumns: TableColumn[];
+    contentColumns: TableColumn[];
+};
+export declare function buildDetailWorkspaceDescription(columns: TableColumn[], row: Record<string, unknown>): string;
+export declare function buildDetailPropertyItems(options: {
+    columns: TableColumn[];
+    fieldDefs: CellFieldDef[];
+    row: Record<string, unknown>;
+}): DatabaseDetailPropertyItem[];
+export declare function resolveDetailPresentation(options: {
+    requested: DatabaseViewDetailPresentation;
+    preferred: DatabaseViewResolvedDetailPresentation | null;
+    isMobileViewport: boolean;
+}): DatabaseViewResolvedDetailPresentation;
+export declare function buildWorkspaceModes(isMobileViewport: boolean): DatabaseWorkspaceModeOption[];