@affino/datagrid-vue-app 0.1.1 → 0.1.2

package/dist/internal.js

@@ -1,14 +1,37 @@
-export { dataGridAppRootElementKey } from "./dataGridAppContext";
-export { buildDataGridChromePaneModel, buildDataGridChromeRenderModel, } from "@affino/datagrid-chrome";
-export { readDataGridOverlayThemeVars } from "./overlays/dataGridOverlayThemeVars";
-export { default as DataGridDefaultRenderer } from "./host/DataGridDefaultRenderer";
-export { default as DataGridGanttStage } from "./gantt/DataGridGanttStage.vue";
-export { default as DataGridModuleHost } from "./host/DataGridModuleHost";
-export { default as DataGridAdvancedFilterPopover } from "./overlays/DataGridAdvancedFilterPopover.vue";
-export { default as DataGridTableStage } from "./stage/DataGridTableStage.vue";
-export { buildDataGridTimelineRenderModels, normalizeDataGridGanttOptions, resolveDataGridTimelineRange, } from "./gantt/dataGridGantt";
-export { resolveDataGridFormulaRowModelOptions } from "./config/dataGridFormulaOptions";
-export { createDataGridTableStageContext, createDataGridTableStageContextFromProps, dataGridTableStageContextKey, provideDataGridTableStageContext, useDataGridTableStageCellsSection, useDataGridTableStageColumnsSection, useDataGridTableStageContext, useDataGridTableStageEditingSection, useDataGridTableStageInteractionSection, useDataGridTableStageLayoutSection, useDataGridTableStageMode, useDataGridTableStageRowHeightMode, useDataGridTableStageRowsSection, useDataGridTableStageSection, useDataGridTableStageSelectionSection, useDataGridTableStageViewportSection, } from "./stage/dataGridTableStageContext";
-export { useDataGridAppRowModel } from "./useDataGridAppRowModel";
-export { useDataGridTableStageBindings } from "./stage/useDataGridTableStageBindings";
-export { useDataGridTableStageRuntime } from "./stage/useDataGridTableStageRuntime";
+import { _ as t, D as i, a as r, b as d, c as s, d as o, e as l, f as n, g as G, p as D, r as S, h as g, u, i as b, j as T, k as c, l as m, m as p, n as R, o as x, q as C, s as M, t as v, v as w, w as f, x as h, y } from "./chunks/useDataGridAppRowModel-CcTL-h8L.js";
+import { buildDataGridChromePaneModel as F, buildDataGridChromeRenderModel as O } from "@affino/datagrid-chrome";
+import { buildDataGridTimelineRenderModels as E, normalizeDataGridGanttOptions as H, resolveDataGridTimelineRange as K } from "@affino/datagrid-gantt";
+export {
+  t as DataGridAdvancedFilterPopover,
+  i as DataGridDefaultRenderer,
+  r as DataGridGanttStage,
+  d as DataGridModuleHost,
+  s as DataGridTableStage,
+  F as buildDataGridChromePaneModel,
+  O as buildDataGridChromeRenderModel,
+  E as buildDataGridTimelineRenderModels,
+  o as createDataGridTableStageContext,
+  l as createDataGridTableStageContextFromProps,
+  n as dataGridAppRootElementKey,
+  G as dataGridTableStageContextKey,
+  H as normalizeDataGridGanttOptions,
+  D as provideDataGridTableStageContext,
+  S as readDataGridOverlayThemeVars,
+  g as resolveDataGridFormulaRowModelOptions,
+  K as resolveDataGridTimelineRange,
+  u as useDataGridAppRowModel,
+  b as useDataGridTableStageBindings,
+  T as useDataGridTableStageCellsSection,
+  c as useDataGridTableStageColumnsSection,
+  m as useDataGridTableStageContext,
+  p as useDataGridTableStageEditingSection,
+  R as useDataGridTableStageInteractionSection,
+  x as useDataGridTableStageLayoutSection,
+  C as useDataGridTableStageMode,
+  M as useDataGridTableStageRowHeightMode,
+  v as useDataGridTableStageRowsSection,
+  w as useDataGridTableStageRuntime,
+  f as useDataGridTableStageSection,
+  h as useDataGridTableStageSelectionSection,
+  y as useDataGridTableStageViewportSection
+};

package/dist/overlays/DataGridAdvancedFilterPopover.vue.d.ts

@@ -0,0 +1,62 @@
+import type { DataGridAppAdvancedFilterClauseDraft, DataGridAppAdvancedFilterClausePatch, DataGridAppAdvancedFilterColumnOption } from "@affino/datagrid-vue";
+type __VLS_Props = {
+    isOpen: boolean;
+    clauses: readonly DataGridAppAdvancedFilterClauseDraft[];
+    columns: readonly DataGridAppAdvancedFilterColumnOption[];
+    appliedFilterSummaryItems?: readonly string[];
+    hasAnyFilters?: boolean;
+    buttonLabel?: string;
+    active?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    appliedFilterSummaryItems: () => never[];
+    hasAnyFilters: boolean;
+    buttonLabel: string;
+    active: boolean;
+}>, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    open: () => void;
+    cancel: () => void;
+    add: () => void;
+    remove: (clauseId: number) => void;
+    apply: () => void;
+    "reset-all": () => void;
+    "update-clause": (payload: DataGridAppAdvancedFilterClausePatch) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    appliedFilterSummaryItems: () => never[];
+    hasAnyFilters: boolean;
+    buttonLabel: string;
+    active: boolean;
+}>>> & {
+    onCancel?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    onAdd?: (() => any) | undefined;
+    onRemove?: ((clauseId: number) => any) | undefined;
+    onApply?: (() => any) | undefined;
+    "onReset-all"?: (() => any) | undefined;
+    "onUpdate-clause"?: ((payload: DataGridAppAdvancedFilterClausePatch) => any) | undefined;
+}, {
+    appliedFilterSummaryItems: readonly string[];
+    hasAnyFilters: boolean;
+    buttonLabel: string;
+    active: boolean;
+}, {}>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/overlays/DataGridAggregationsPopover.vue.d.ts

@@ -0,0 +1,62 @@
+import type { DataGridAggregationPanelItem } from "../config/dataGridAggregations";
+type __VLS_Props = {
+    isOpen: boolean;
+    basis: "filtered" | "source";
+    items: readonly DataGridAggregationPanelItem[];
+    buttonLabel?: string;
+    active?: boolean;
+    disabled?: boolean;
+    disabledReason?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    buttonLabel: string;
+    active: boolean;
+    disabled: boolean;
+    disabledReason: string;
+}>, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    open: () => void;
+    cancel: () => void;
+    apply: () => void;
+    clear: () => void;
+    "update-basis": (basis: "source" | "filtered") => void;
+    "toggle-column": (key: string, enabled: boolean) => void;
+    "update-op": (key: string, op: string) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    buttonLabel: string;
+    active: boolean;
+    disabled: boolean;
+    disabledReason: string;
+}>>> & {
+    onCancel?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    onApply?: (() => any) | undefined;
+    onClear?: (() => any) | undefined;
+    "onUpdate-basis"?: ((basis: "source" | "filtered") => any) | undefined;
+    "onToggle-column"?: ((key: string, enabled: boolean) => any) | undefined;
+    "onUpdate-op"?: ((key: string, op: string) => any) | undefined;
+}, {
+    disabled: boolean;
+    buttonLabel: string;
+    active: boolean;
+    disabledReason: string;
+}, {}>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/overlays/DataGridCellComboboxEditor.vue.d.ts

@@ -0,0 +1,29 @@
+import type { DataGridFilterableComboboxOption } from "./dataGridFilterableCombobox";
+type CommitTarget = "stay" | "next" | "previous";
+type __VLS_Props = {
+    value: string;
+    options?: ReadonlyArray<DataGridFilterableComboboxOption>;
+    loadOptions?: (query: string) => Promise<ReadonlyArray<DataGridFilterableComboboxOption>>;
+    placeholder?: string;
+    initialFilter?: string;
+    openOnMount?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    commit: (value: string, target?: CommitTarget | undefined) => void;
+    cancel: () => void;
+    optionsResolved: (options: readonly DataGridFilterableComboboxOption[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    onCancel?: (() => any) | undefined;
+    onOptionsResolved?: ((options: readonly DataGridFilterableComboboxOption[]) => any) | undefined;
+    onCommit?: ((value: string, target?: CommitTarget | undefined) => any) | undefined;
+}, {}, {}>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};

package/dist/overlays/DataGridColumnLayoutPopover.vue.d.ts

@@ -0,0 +1,51 @@
+import type { DataGridAppColumnLayoutPanelItem, DataGridAppColumnLayoutVisibilityPatch } from "@affino/datagrid-vue";
+type __VLS_Props = {
+    isOpen: boolean;
+    items: readonly DataGridAppColumnLayoutPanelItem[];
+    buttonLabel?: string;
+    active?: boolean;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    buttonLabel: string;
+    active: boolean;
+}>, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    open: () => void;
+    cancel: () => void;
+    apply: () => void;
+    "toggle-visibility": (payload: DataGridAppColumnLayoutVisibilityPatch) => void;
+    "move-up": (key: string) => void;
+    "move-down": (key: string) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<__VLS_Props>, {
+    buttonLabel: string;
+    active: boolean;
+}>>> & {
+    onCancel?: (() => any) | undefined;
+    onOpen?: (() => any) | undefined;
+    onApply?: (() => any) | undefined;
+    "onToggle-visibility"?: ((payload: DataGridAppColumnLayoutVisibilityPatch) => any) | undefined;
+    "onMove-up"?: ((key: string) => any) | undefined;
+    "onMove-down"?: ((key: string) => any) | undefined;
+}, {
+    buttonLabel: string;
+    active: boolean;
+}, {}>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/overlays/DataGridColumnMenu.vue.d.ts

@@ -0,0 +1,65 @@
+import type { DataGridColumnMenuActionOptions, DataGridColumnMenuDisabledReasons, DataGridColumnMenuItemKey, DataGridColumnMenuItemLabels } from "./dataGridColumnMenu";
+type DataGridColumnPin = "left" | "right" | "none";
+type __VLS_Props = {
+    rows: readonly Record<string, unknown>[];
+    items: readonly DataGridColumnMenuItemKey[];
+    disabledItems: readonly DataGridColumnMenuItemKey[];
+    disabledReasons: DataGridColumnMenuDisabledReasons;
+    labels: DataGridColumnMenuItemLabels;
+    actionOptions: DataGridColumnMenuActionOptions;
+    columnKey: string;
+    columnLabel: string;
+    columnDataType?: string;
+    sortDirection: "asc" | "desc" | null;
+    sortEnabled: boolean;
+    pin: DataGridColumnPin;
+    grouped: boolean;
+    groupOrder: number | null;
+    groupEnabled: boolean;
+    filterEnabled: boolean;
+    valueFilterRowLimit: number;
+    textFilterEnabled: boolean;
+    textFilterValue: string;
+    filterActive: boolean;
+    selectedFilterTokens: readonly string[];
+    maxFilterValues: number;
+};
+declare function toggleMenuFromElement(element: HTMLElement | null): void;
+declare var __VLS_15: {
+    open: boolean;
+    toggleMenuFromElement: typeof toggleMenuFromElement;
+};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_15) => any;
+};
+declare const __VLS_base: import("vue").DefineComponent<__VLS_TypePropsToOption<__VLS_Props>, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    sort: (direction: "desc" | "asc" | null) => void;
+    pin: (pin: DataGridColumnPin) => void;
+    group: (grouped: boolean) => void;
+    "apply-filter": (tokens: readonly string[]) => void;
+    "clear-filter": () => void;
+    "update-text-filter": (value: string) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_TypePropsToOption<__VLS_Props>>> & {
+    onSort?: ((direction: "desc" | "asc" | null) => any) | undefined;
+    onGroup?: ((grouped: boolean) => any) | undefined;
+    onPin?: ((pin: DataGridColumnPin) => any) | undefined;
+    "onApply-filter"?: ((tokens: readonly string[]) => any) | undefined;
+    "onClear-filter"?: (() => any) | undefined;
+    "onUpdate-text-filter"?: ((value: string) => any) | undefined;
+}, {}, {}>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/overlays/DataGridFilterableCombobox.vue.d.ts

@@ -0,0 +1,76 @@
+import { type DataGridFilterableComboboxOption } from "./dataGridFilterableCombobox";
+declare const _default: typeof __VLS_export;
+export default _default;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_WithDefaults<__VLS_TypePropsToOption<{
+    value: string;
+    options?: ReadonlyArray<DataGridFilterableComboboxOption>;
+    loadOptions?: (query: string) => Promise<ReadonlyArray<DataGridFilterableComboboxOption>>;
+    placeholder?: string;
+    disabled?: boolean;
+    openOnMount?: boolean;
+    initialFilter?: string;
+    openOnFocus?: boolean;
+    inlinePanel?: boolean;
+    stickyPopoverId?: string;
+}>, {
+    options: () => never[];
+    placeholder: string;
+    disabled: boolean;
+    openOnMount: boolean;
+    initialFilter: string;
+    openOnFocus: boolean;
+    inlinePanel: boolean;
+}>, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    commit: (value: string, target?: ("stay" | "next" | "previous") | undefined) => void;
+    cancel: () => void;
+    optionsResolved: (options: readonly DataGridFilterableComboboxOption[]) => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<__VLS_WithDefaults<__VLS_TypePropsToOption<{
+    value: string;
+    options?: ReadonlyArray<DataGridFilterableComboboxOption>;
+    loadOptions?: (query: string) => Promise<ReadonlyArray<DataGridFilterableComboboxOption>>;
+    placeholder?: string;
+    disabled?: boolean;
+    openOnMount?: boolean;
+    initialFilter?: string;
+    openOnFocus?: boolean;
+    inlinePanel?: boolean;
+    stickyPopoverId?: string;
+}>, {
+    options: () => never[];
+    placeholder: string;
+    disabled: boolean;
+    openOnMount: boolean;
+    initialFilter: string;
+    openOnFocus: boolean;
+    inlinePanel: boolean;
+}>>> & {
+    onCancel?: (() => any) | undefined;
+    onOptionsResolved?: ((options: readonly DataGridFilterableComboboxOption[]) => any) | undefined;
+    onCommit?: ((value: string, target?: ("stay" | "next" | "previous") | undefined) => any) | undefined;
+}, {
+    options: ReadonlyArray<DataGridFilterableComboboxOption>;
+    placeholder: string;
+    disabled: boolean;
+    openOnMount: boolean;
+    initialFilter: string;
+    openOnFocus: boolean;
+    inlinePanel: boolean;
+}, {}>;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: import('vue').PropType<Required<T>[K]>;
+    } : {
+        type: import('vue').PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithDefaults<P, D> = {
+    [K in keyof Pick<P, keyof P>]: K extends keyof D ? __VLS_PrettifyLocal<P[K] & {
+        default: D[K];
+    }> : P[K];
+};
+type __VLS_PrettifyLocal<T> = (T extends any ? {
+    [K in keyof T]: T[K];
+} : {
+    [K in keyof T as K]: T[K];
+}) & {};

package/dist/stage/DataGridTableStage.vue.d.ts

@@ -0,0 +1,115 @@
+import { type PropType } from "vue";
+import type { DataGridTableStageProps } from "./dataGridTableStage.types";
+import { type DataGridTableStageContext } from "./dataGridTableStageContext";
+declare const __VLS_export: import("vue").DefineComponent<{
+    mode: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["mode"]>;
+        required: true;
+    };
+    rowHeightMode: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["rowHeightMode"]>;
+        required: true;
+    };
+    layout: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["layout"]>;
+        required: true;
+    };
+    viewport: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["viewport"]>;
+        required: true;
+    };
+    columns: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["columns"]>;
+        required: true;
+    };
+    rows: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["rows"]>;
+        required: true;
+    };
+    selection: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["selection"]>;
+        required: true;
+    };
+    editing: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["editing"]>;
+        required: true;
+    };
+    cells: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["cells"]>;
+        required: true;
+    };
+    interaction: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["interaction"]>;
+        required: true;
+    };
+    onViewportContextMenu: {
+        type: PropType<(event: MouseEvent) => void>;
+        default: undefined;
+    };
+    stageContext: {
+        type: PropType<DataGridTableStageContext<Record<string, unknown>>>;
+        default: undefined;
+    };
+}, {
+    getStageRootElement: () => HTMLElement | null;
+    getHeaderElement: () => HTMLElement | null;
+    getBodyViewportElement: () => HTMLElement | null;
+    getVisibleRowMetrics: () => readonly {
+        top: number;
+        height: number;
+    }[];
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    mode: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["mode"]>;
+        required: true;
+    };
+    rowHeightMode: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["rowHeightMode"]>;
+        required: true;
+    };
+    layout: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["layout"]>;
+        required: true;
+    };
+    viewport: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["viewport"]>;
+        required: true;
+    };
+    columns: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["columns"]>;
+        required: true;
+    };
+    rows: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["rows"]>;
+        required: true;
+    };
+    selection: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["selection"]>;
+        required: true;
+    };
+    editing: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["editing"]>;
+        required: true;
+    };
+    cells: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["cells"]>;
+        required: true;
+    };
+    interaction: {
+        type: PropType<DataGridTableStageProps<Record<string, unknown>>["interaction"]>;
+        required: true;
+    };
+    onViewportContextMenu: {
+        type: PropType<(event: MouseEvent) => void>;
+        default: undefined;
+    };
+    stageContext: {
+        type: PropType<DataGridTableStageContext<Record<string, unknown>>>;
+        default: undefined;
+    };
+}>>, {
+    onViewportContextMenu: (event: MouseEvent) => void;
+    stageContext: DataGridTableStageContext<Record<string, unknown>>;
+}, {}>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/stage/DataGridTableStageCenterPane.vue.d.ts

@@ -0,0 +1,121 @@
+import { type PropType } from "vue";
+import type { DataGridTableStageBodyRow, DataGridTableStageCenterPaneRenderApi, DataGridTableStageOverlaySegment } from "./dataGridTableStageBody.types";
+import type { DataGridElementRefHandler } from "./dataGridTableStage.types";
+declare const __VLS_export: import("vue").DefineComponent<{
+    viewportRef: {
+        type: PropType<DataGridElementRefHandler>;
+        default: undefined;
+    };
+    displayRows: {
+        type: PropType<readonly DataGridTableStageBodyRow[]>;
+        required: true;
+    };
+    topSpacerHeight: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    bottomSpacerHeight: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    viewportClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    handleScroll: {
+        type: PropType<(event: Event) => void>;
+        default: undefined;
+    };
+    handleWheel: {
+        type: PropType<(event: WheelEvent) => void>;
+        default: undefined;
+    };
+    handleKeydown: {
+        type: PropType<(event: KeyboardEvent) => void>;
+        default: undefined;
+    };
+    handleContextMenu: {
+        type: PropType<(event: MouseEvent) => void>;
+        default: undefined;
+    };
+    selectionOverlaySegments: {
+        type: PropType<readonly DataGridTableStageOverlaySegment[]>;
+        required: true;
+    };
+    fillPreviewOverlaySegments: {
+        type: PropType<readonly DataGridTableStageOverlaySegment[]>;
+        required: true;
+    };
+    movePreviewOverlaySegments: {
+        type: PropType<readonly DataGridTableStageOverlaySegment[]>;
+        required: true;
+    };
+    renderApi: {
+        type: PropType<DataGridTableStageCenterPaneRenderApi>;
+        required: true;
+    };
+}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    viewportRef: {
+        type: PropType<DataGridElementRefHandler>;
+        default: undefined;
+    };
+    displayRows: {
+        type: PropType<readonly DataGridTableStageBodyRow[]>;
+        required: true;
+    };
+    topSpacerHeight: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    bottomSpacerHeight: {
+        type: NumberConstructor;
+        default: undefined;
+    };
+    viewportClass: {
+        type: StringConstructor;
+        default: string;
+    };
+    handleScroll: {
+        type: PropType<(event: Event) => void>;
+        default: undefined;
+    };
+    handleWheel: {
+        type: PropType<(event: WheelEvent) => void>;
+        default: undefined;
+    };
+    handleKeydown: {
+        type: PropType<(event: KeyboardEvent) => void>;
+        default: undefined;
+    };
+    handleContextMenu: {
+        type: PropType<(event: MouseEvent) => void>;
+        default: undefined;
+    };
+    selectionOverlaySegments: {
+        type: PropType<readonly DataGridTableStageOverlaySegment[]>;
+        required: true;
+    };
+    fillPreviewOverlaySegments: {
+        type: PropType<readonly DataGridTableStageOverlaySegment[]>;
+        required: true;
+    };
+    movePreviewOverlaySegments: {
+        type: PropType<readonly DataGridTableStageOverlaySegment[]>;
+        required: true;
+    };
+    renderApi: {
+        type: PropType<DataGridTableStageCenterPaneRenderApi>;
+        required: true;
+    };
+}>>, {
+    handleKeydown: (event: KeyboardEvent) => void;
+    topSpacerHeight: number;
+    bottomSpacerHeight: number;
+    viewportRef: DataGridElementRefHandler;
+    viewportClass: string;
+    handleScroll: (event: Event) => void;
+    handleWheel: (event: WheelEvent) => void;
+    handleContextMenu: (event: MouseEvent) => void;
+}, {}>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/stage/DataGridTableStageFillActionMenu.vue.d.ts

@@ -0,0 +1,30 @@
+import { type CSSProperties, type PropType } from "vue";
+declare const __VLS_export: import("vue").DefineComponent<{
+    isOpen: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    style: {
+        type: PropType<CSSProperties | null>;
+        default: null;
+    };
+}, unknown, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    toggle: (event: MouseEvent) => void;
+    selected: () => void;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    isOpen: {
+        type: BooleanConstructor;
+        required: true;
+    };
+    style: {
+        type: PropType<CSSProperties | null>;
+        default: null;
+    };
+}>> & {
+    onToggle?: ((event: MouseEvent) => any) | undefined;
+    onSelected?: (() => any) | undefined;
+}, {
+    style: CSSProperties | null;
+}, {}>;
+declare const _default: typeof __VLS_export;
+export default _default;