@uipath/apollo-vertex 0.0.0-stage → 0.3.0

package/dist/registry/data-fabric-adapter/utils/fetch-date-binned-data.js

@@ -0,0 +1,92 @@
+import { DateTime } from "luxon";
+import { z } from "zod";
+import { niceDurationNumbers } from "../../charts-core/charts-core.js";
+import { buildIntervalsFromDateBins, createDateBinning, durationToDateBinUnit } from "./binning-utils.js";
+import { mapFilterValuesToDataFabricFilterGroup } from "./filter-group.js";
+import { dataFabricQuery } from "./query.js";
+async function fetchDateBinnedData({ client, entityName, dimensionId, aggregates, filters, joins, from }) {
+    const baseFilterGroup = mapFilterValuesToDataFabricFilterGroup(filters);
+    const minMaxBody = {
+        aggregates: [
+            {
+                function: "MIN",
+                field: dimensionId,
+                alias: "min"
+            },
+            {
+                function: "MAX",
+                field: dimensionId,
+                alias: "max"
+            }
+        ],
+        filterGroup: baseFilterGroup,
+        joins,
+        from
+    };
+    const minMaxResult = await dataFabricQuery(client, entityName, minMaxBody, "Failed to fetch min/max");
+    const row = minMaxResult.value[0];
+    if (!row) throw new Error("Min/max query returned no results");
+    const minStr = z.string().nullable().parse(row.min ?? null);
+    const maxStr = z.string().nullable().parse(row.max ?? null);
+    if (!minStr || !maxStr) throw new Error("Min/max query returned null values");
+    const min = DateTime.fromISO(minStr, {
+        zone: "utc"
+    });
+    const max = DateTime.fromISO(maxStr, {
+        zone: "utc"
+    });
+    if (min.equals(max)) return null;
+    const bestDuration = niceDurationNumbers({
+        min,
+        max
+    });
+    const dateBinUnit = durationToDateBinUnit(bestDuration);
+    const binning = createDateBinning(dimensionId, dateBinUnit);
+    const minIso = min.toISO() ?? minStr;
+    const maxIso = max.toISO() ?? maxStr;
+    const existingFilters = baseFilterGroup?.queryFilters ?? [];
+    const requestBody = {
+        selectedFields: [
+            dimensionId
+        ],
+        aggregates,
+        binnings: [
+            binning
+        ],
+        joins,
+        from,
+        filterGroup: {
+            logicalOperator: "and",
+            queryFilters: [
+                ...existingFilters,
+                {
+                    fieldName: dimensionId,
+                    operator: ">=",
+                    value: minIso
+                },
+                {
+                    fieldName: dimensionId,
+                    operator: "<=",
+                    value: maxIso
+                }
+            ]
+        },
+        sortOptions: [
+            {
+                fieldName: dimensionId,
+                isDescending: false
+            }
+        ],
+        top: 1000,
+        skip: 0
+    };
+    const dataResult = await dataFabricQuery(client, entityName, requestBody, "Failed to fetch binned data");
+    const rows = dataResult.value;
+    const dateBinValues = rows.map((r)=>z.string().parse(r[dimensionId]));
+    const bins = buildIntervalsFromDateBins(dateBinValues, dateBinUnit);
+    return {
+        bins,
+        rows
+    };
+}
+export { fetchDateBinnedData };

package/dist/registry/data-fabric-adapter/utils/filter-group.d.ts

@@ -0,0 +1,3 @@
+import type { FilterValues } from "../../charts-core/charts-core";
+import type { DataFabricQueryRequest } from "../schemas/query-schema";
+export declare function mapFilterValuesToDataFabricFilterGroup(filters: FilterValues[]): DataFabricQueryRequest["filterGroup"] | undefined;

package/dist/registry/data-fabric-adapter/utils/filter-group.js

@@ -0,0 +1,103 @@
+import { DateTime } from "luxon";
+function toFilterValue(value) {
+    if (value instanceof DateTime) return value.toISO() ?? "";
+    if ("string" == typeof value || "number" == typeof value || "boolean" == typeof value) return value;
+    return null;
+}
+function mapFilterValuesToDataFabricFilterGroup(filters) {
+    if (0 === filters.length) return;
+    const queryFilters = filters.flatMap((filter)=>{
+        switch(filter.type){
+            case "list":
+                {
+                    const fieldName = filter.field;
+                    const values = filter.values;
+                    const invert = !!filter.invert;
+                    if (0 === values.length) return [];
+                    if (1 === values.length) {
+                        const operator = invert ? "!=" : "=";
+                        return [
+                            {
+                                fieldName,
+                                operator,
+                                value: values[0] ?? null
+                            }
+                        ];
+                    }
+                    if (invert) return values.filter((v)=>null != v).map((value)=>({
+                            fieldName,
+                            operator: "!=",
+                            value
+                        }));
+                    return [
+                        {
+                            fieldName,
+                            operator: "in",
+                            value: JSON.stringify(values.filter((v)=>null != v))
+                        }
+                    ];
+                }
+            case "search":
+                {
+                    const operator = "startsWith" === filter.searchFilterType ? "startswith" : "endsWith" === filter.searchFilterType ? "endswith" : "contains";
+                    return [
+                        {
+                            fieldName: filter.field,
+                            operator,
+                            value: filter.pattern
+                        }
+                    ];
+                }
+            case "period":
+                {
+                    const minIso = filter.range.min.toISO();
+                    const maxIso = filter.range.max.toISO();
+                    return [
+                        ...null == minIso ? [] : [
+                            {
+                                fieldName: filter.field,
+                                operator: ">=",
+                                value: minIso
+                            }
+                        ],
+                        ...null == maxIso ? [] : [
+                            {
+                                fieldName: filter.field,
+                                operator: "<=",
+                                value: maxIso
+                            }
+                        ]
+                    ];
+                }
+            case "range":
+                {
+                    const minVal = toFilterValue(filter.range.min);
+                    const maxVal = toFilterValue(filter.range.max);
+                    return [
+                        ...null == minVal ? [] : [
+                            {
+                                fieldName: filter.field,
+                                operator: ">=",
+                                value: minVal
+                            }
+                        ],
+                        ...null == maxVal ? [] : [
+                            {
+                                fieldName: filter.field,
+                                operator: "<=",
+                                value: maxVal
+                            }
+                        ]
+                    ];
+                }
+            default:
+                return [];
+        }
+    });
+    if (0 === queryFilters.length) return;
+    return {
+        logicalOperator: "and",
+        queryFilters
+    };
+}
+export { mapFilterValuesToDataFabricFilterGroup };

package/dist/registry/data-fabric-adapter/utils/metric-aggregate.d.ts

@@ -0,0 +1,9 @@
+import type { DataModelMetric } from "../../charts-core/charts-core";
+type DataFabricFunction = "COUNT" | "SUM" | "AVG" | "MIN" | "MAX";
+export interface DataFabricAggregate {
+    function: DataFabricFunction;
+    field: string;
+    alias: string;
+}
+export declare function mapMetricToDataFabricAggregate(metric: DataModelMetric): DataFabricAggregate;
+export {};

package/dist/registry/data-fabric-adapter/utils/metric-aggregate.js

@@ -0,0 +1,44 @@
+function mapMetricToDataFabricAggregate(metric) {
+    const expr = metric.expression;
+    if (expr.filters && expr.filters.length > 0) throw new Error(`Data Fabric does not support per-aggregate filters (metric "${metric.id}").`);
+    const field = expr.argument.id;
+    switch(expr.aggregation){
+        case "COUNT":
+            return {
+                function: "COUNT",
+                field,
+                alias: metric.id
+            };
+        case "SUM":
+            return {
+                function: "SUM",
+                field,
+                alias: metric.id
+            };
+        case "AVERAGE":
+            return {
+                function: "AVG",
+                field,
+                alias: metric.id
+            };
+        case "MIN":
+            return {
+                function: "MIN",
+                field,
+                alias: metric.id
+            };
+        case "MAX":
+            return {
+                function: "MAX",
+                field,
+                alias: metric.id
+            };
+        case "ANY":
+        case "DISTINCT_COUNT":
+        case "MEDIAN":
+        case "PERCENTAGE":
+        case "PERCENTILE":
+            throw new Error(`Data Fabric does not support aggregation "${expr.aggregation}" (metric "${metric.id}").`);
+    }
+}
+export { mapMetricToDataFabricAggregate };

package/dist/registry/data-fabric-adapter/utils/query-options.d.ts

@@ -0,0 +1,14 @@
+import type { FilterValues } from "../../charts-core/charts-core";
+import type { DataFabricQueryRequest } from "../schemas/query-schema";
+interface DataFabricChartQueryOptions {
+    selectedFields: string[];
+    sortBy: {
+        field: string;
+        direction: "asc" | "desc";
+    } | null;
+    filters?: FilterValues[];
+    skip?: number;
+    top?: number;
+}
+export declare function createDataFabricChartQueryOptions({ selectedFields, sortBy, filters, skip, top, }: DataFabricChartQueryOptions): Omit<DataFabricQueryRequest, "aggregates" | "groupBy" | "binnings">;
+export {};

package/dist/registry/data-fabric-adapter/utils/query-options.js

@@ -0,0 +1,17 @@
+import { mapFilterValuesToDataFabricFilterGroup } from "./filter-group.js";
+function createDataFabricChartQueryOptions({ selectedFields, sortBy, filters = [], skip = 0, top = 100 }) {
+    const result = {
+        selectedFields,
+        skip,
+        top,
+        filterGroup: mapFilterValuesToDataFabricFilterGroup(filters)
+    };
+    if (sortBy) result.sortOptions = [
+        {
+            fieldName: sortBy.field,
+            isDescending: "desc" === sortBy.direction
+        }
+    ];
+    return result;
+}
+export { createDataFabricChartQueryOptions };

package/dist/registry/data-fabric-adapter/utils/query.d.ts

@@ -0,0 +1,7 @@
+import type { InitClientReturn } from "@ts-rest/core";
+import type { dataFabricContract } from "../contract";
+import type { DataFabricQueryRequest, DataFabricQueryResponse } from "../schemas/query-schema";
+export type DataFabricClient = InitClientReturn<typeof dataFabricContract, {
+    baseUrl: string;
+}>;
+export declare function dataFabricQuery(client: DataFabricClient, entityName: string, body: DataFabricQueryRequest, errorMessage: string): Promise<DataFabricQueryResponse>;

package/dist/registry/data-fabric-adapter/utils/query.js

@@ -0,0 +1,12 @@
+import { throwDataFabricError } from "./throw-error.js";
+async function dataFabricQuery(client, entityName, body, errorMessage) {
+    const result = await client.query({
+        params: {
+            entityName
+        },
+        body
+    });
+    if (200 !== result.status) throwDataFabricError(result, errorMessage);
+    return result.body;
+}
+export { dataFabricQuery };

package/dist/registry/data-fabric-adapter/utils/response-data-mapper.d.ts

@@ -0,0 +1,3 @@
+import type { DataQueryResponse } from "../../charts-core/charts-core";
+import type { DataFabricQueryResponse } from "../schemas/query-schema";
+export declare function mapDataFabricResponseToChartData(response: DataFabricQueryResponse, fieldIds: string[]): DataQueryResponse;

package/dist/registry/data-fabric-adapter/utils/response-data-mapper.js

@@ -0,0 +1,15 @@
+function mapDataFabricResponseToChartData(response, fieldIds) {
+    const { value: rows } = response;
+    const columnKeys = [
+        ...fieldIds,
+        ...rows[0] ? Object.keys(rows[0]).filter((k)=>!fieldIds.includes(k)) : []
+    ];
+    const result = {};
+    for (const key of columnKeys)result[key] = {
+        values: rows.map((row)=>row[key] ?? null),
+        stackValues: null,
+        ungrouped: null
+    };
+    return result;
+}
+export { mapDataFabricResponseToChartData };

package/dist/registry/data-fabric-adapter/utils/throw-error.d.ts

@@ -0,0 +1,8 @@
+export declare function throwDataFabricError(result: {
+    status: 400;
+    body: {
+        error?: {
+            message?: string;
+        };
+    };
+}, fallback: string): never;

package/dist/registry/data-fabric-adapter/utils/throw-error.js

@@ -0,0 +1,5 @@
+function throwDataFabricError(result, fallback) {
+    const err = result.body.error;
+    throw new Error("object" == typeof err && err?.message ? err.message : fallback);
+}
+export { throwDataFabricError };

package/dist/registry/data-table/data-table-column-header.d.ts

@@ -0,0 +1,8 @@
+import type { Column } from "@tanstack/react-table";
+import * as React from "react";
+interface DataTableColumnHeaderProps<TData, TValue> extends React.HTMLAttributes<HTMLDivElement> {
+    column: Column<TData, TValue>;
+    title: string;
+}
+declare function DataTableColumnHeader<TData, TValue>({ column, title, className, }: DataTableColumnHeaderProps<TData, TValue>): import("react/jsx-runtime").JSX.Element;
+export { DataTableColumnHeader };

package/dist/registry/data-table/data-table-column-header.js

@@ -0,0 +1,44 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { ArrowDownIcon, ArrowUpIcon } from "lucide-react";
+import "react";
+import { Button } from "../button/button.js";
+import { cn } from "../../lib/utils.js";
+function SortIcon({ sortDirection }) {
+    if ("asc" === sortDirection) return /*#__PURE__*/ jsx(ArrowUpIcon, {
+        className: "size-3.5"
+    });
+    if ("desc" === sortDirection) return /*#__PURE__*/ jsx(ArrowDownIcon, {
+        className: "size-3.5"
+    });
+    return /*#__PURE__*/ jsx(ArrowUpIcon, {
+        className: "size-3.5 opacity-0 group-hover/sort:opacity-40 transition-opacity"
+    });
+}
+function DataTableColumnHeader({ column, title, className }) {
+    "use no memo";
+    if (!column.getCanSort()) return /*#__PURE__*/ jsx("div", {
+        className: cn(className),
+        children: title
+    });
+    return /*#__PURE__*/ jsx("div", {
+        "data-slot": "data-table-column-header",
+        className: cn("flex items-center gap-2", className),
+        children: /*#__PURE__*/ jsxs(Button, {
+            variant: "ghost",
+            size: "sm",
+            onClick: ()=>column.toggleSorting("asc" === column.getIsSorted()),
+            className: "group/sort gap-1.5 -mx-2.5 -my-1 px-2.5 text-xs font-semibold text-muted-foreground",
+            children: [
+                /*#__PURE__*/ jsx("span", {
+                    className: "truncate",
+                    children: title
+                }),
+                /*#__PURE__*/ jsx(SortIcon, {
+                    sortDirection: column.getIsSorted()
+                })
+            ]
+        })
+    });
+}
+export { DataTableColumnHeader };

package/dist/registry/data-table/data-table-expand-toggle.d.ts

@@ -0,0 +1,12 @@
+import type { Table as TanstackTable } from "@tanstack/react-table";
+interface DataTableExpandAllToggleProps<TData> {
+    table: TanstackTable<TData>;
+}
+/**
+ * Expand/collapse-all toggle for a data table's expand-column header. Reflects
+ * and toggles the table's all-rows-expanded state, with distinct double-chevron
+ * icons to set it apart from the per-row single-chevron expand controls.
+ */
+declare function DataTableExpandAllToggle<TData>({ table, }: DataTableExpandAllToggleProps<TData>): import("react/jsx-runtime").JSX.Element;
+export { DataTableExpandAllToggle };
+export type { DataTableExpandAllToggleProps };

package/dist/registry/data-table/data-table-expand-toggle.js

@@ -0,0 +1,27 @@
+"use client";
+import { jsx } from "react/jsx-runtime";
+import { ChevronsDownUp, ChevronsUpDown } from "lucide-react";
+import { useVertexTranslation } from "../../lib/vertex-translation.js";
+import { Button } from "../button/button.js";
+function DataTableExpandAllToggle({ table }) {
+    const { t } = useVertexTranslation();
+    const allExpanded = table.getIsAllRowsExpanded();
+    return /*#__PURE__*/ jsx(Button, {
+        type: "button",
+        variant: "ghost",
+        size: "icon-sm",
+        "aria-pressed": allExpanded,
+        "aria-label": allExpanded ? t("collapse_all", {
+            defaultValue: "Collapse all"
+        }) : t("expand_all", {
+            defaultValue: "Expand all"
+        }),
+        onClick: ()=>table.toggleAllRowsExpanded(),
+        children: allExpanded ? /*#__PURE__*/ jsx(ChevronsDownUp, {
+            className: "size-4"
+        }) : /*#__PURE__*/ jsx(ChevronsUpDown, {
+            className: "size-4"
+        })
+    });
+}
+export { DataTableExpandAllToggle };

package/dist/registry/data-table/data-table-filters.d.ts

@@ -0,0 +1,3 @@
+import type { Row, RowData } from "@tanstack/react-table";
+export declare const dataTableGlobalFilterFn: (row: Row<RowData>, _columnId: string, filterValue: string) => boolean;
+export declare const dataTableFacetedFilterFn: (row: Row<RowData>, columnId: string, filterValue: unknown) => boolean;

package/dist/registry/data-table/data-table-filters.js

@@ -0,0 +1,16 @@
+const dataTableGlobalFilterFn = (row, _columnId, filterValue)=>{
+    if (!filterValue) return true;
+    const searchStr = filterValue.toLowerCase();
+    return row.getVisibleCells().some((cell)=>{
+        const value = cell.getValue();
+        const meta = cell.column.columnDef.meta;
+        const displayValue = meta?.getFilterValue ? meta.getFilterValue(value, row) : "string" == typeof value ? value : "number" == typeof value || "boolean" == typeof value ? String(value) : "";
+        return displayValue.toLowerCase().includes(searchStr);
+    });
+};
+const dataTableFacetedFilterFn = (row, columnId, filterValue)=>{
+    if (!filterValue || !Array.isArray(filterValue) || 0 === filterValue.length) return true;
+    const cellValue = String(row.getValue(columnId) ?? "");
+    return filterValue.includes(cellValue);
+};
+export { dataTableFacetedFilterFn, dataTableGlobalFilterFn };

package/dist/registry/data-table/data-table-pagination.d.ts

@@ -0,0 +1,8 @@
+import type { Table as TanstackTable } from "@tanstack/react-table";
+interface DataTablePaginationProps<TData> {
+    table: TanstackTable<TData>;
+    paginationSizes?: number[];
+    className?: string;
+}
+declare function DataTablePagination<TData>({ table, paginationSizes, className, }: DataTablePaginationProps<TData>): import("react/jsx-runtime").JSX.Element;
+export { DataTablePagination };

package/dist/registry/data-table/data-table-pagination.js

@@ -0,0 +1,166 @@
+"use client";
+import { jsx, jsxs } from "react/jsx-runtime";
+import { ChevronLeftIcon, ChevronRightIcon, ChevronsLeftIcon, ChevronsRightIcon } from "lucide-react";
+import { useVertexTranslation } from "../../lib/vertex-translation.js";
+import { Button } from "../button/button.js";
+import { Select, SelectContent, SelectItem, SelectTrigger, SelectValue } from "../select/select.js";
+import { cn } from "../../lib/utils.js";
+function DataTablePagination({ table, paginationSizes = [
+    10,
+    25,
+    50,
+    100
+], className }) {
+    "use no memo";
+    const { t } = useVertexTranslation();
+    const { pageIndex, pageSize } = table.getState().pagination;
+    const totalRows = table.getFilteredRowModel().rows.length;
+    const pageCount = table.getPageCount();
+    const canPreviousPage = pageIndex > 0;
+    const canNextPage = pageCount > 0 && pageIndex < pageCount - 1;
+    return /*#__PURE__*/ jsxs("div", {
+        "data-slot": "data-table-pagination",
+        className: cn("flex items-center justify-between px-2 flex-wrap gap-2", className),
+        children: [
+            /*#__PURE__*/ jsx("div", {
+                className: "text-muted-foreground flex-1 text-sm",
+                children: table.options.enableRowSelection && t("rows_selected", {
+                    selected: table.getFilteredSelectedRowModel().rows.length,
+                    total: totalRows,
+                    defaultValue: "{{selected}} of {{total}} row(s) selected."
+                })
+            }),
+            /*#__PURE__*/ jsxs("div", {
+                className: "flex items-center space-x-6 lg:space-x-8",
+                children: [
+                    /*#__PURE__*/ jsxs("div", {
+                        className: "flex items-center space-x-2",
+                        children: [
+                            /*#__PURE__*/ jsx("p", {
+                                className: "text-sm font-medium",
+                                children: t("rows_per_page", {
+                                    defaultValue: "Rows per page"
+                                })
+                            }),
+                            /*#__PURE__*/ jsxs(Select, {
+                                value: paginationSizes.includes(pageSize) ? `${pageSize}` : "all",
+                                onValueChange: (value)=>{
+                                    table.setPageSize("all" === value ? Number.MAX_SAFE_INTEGER : Number(value));
+                                },
+                                children: [
+                                    /*#__PURE__*/ jsx(SelectTrigger, {
+                                        size: "sm",
+                                        className: "w-[80px]",
+                                        children: /*#__PURE__*/ jsx(SelectValue, {
+                                            placeholder: pageSize
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsxs(SelectContent, {
+                                        side: "top",
+                                        position: "popper",
+                                        children: [
+                                            paginationSizes.map((size)=>/*#__PURE__*/ jsx(SelectItem, {
+                                                    value: `${size}`,
+                                                    children: size
+                                                }, size)),
+                                            /*#__PURE__*/ jsx(SelectItem, {
+                                                value: "all",
+                                                children: t("all", {
+                                                    defaultValue: "All"
+                                                })
+                                            })
+                                        ]
+                                    })
+                                ]
+                            })
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs("div", {
+                        className: "flex w-[100px] items-center justify-center text-sm font-medium",
+                        children: [
+                            t("page", {
+                                defaultValue: "Page"
+                            }),
+                            " ",
+                            pageIndex + 1,
+                            " ",
+                            t("of", {
+                                defaultValue: "of"
+                            }),
+                            " ",
+                            pageCount
+                        ]
+                    }),
+                    /*#__PURE__*/ jsxs("div", {
+                        className: "flex items-center space-x-2",
+                        children: [
+                            /*#__PURE__*/ jsxs(Button, {
+                                variant: "outline",
+                                size: "icon-sm",
+                                className: "hidden lg:flex",
+                                onClick: ()=>table.setPageIndex(0),
+                                disabled: !canPreviousPage,
+                                children: [
+                                    /*#__PURE__*/ jsx("span", {
+                                        className: "sr-only",
+                                        children: t("go_to_first_page", {
+                                            defaultValue: "Go to first page"
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(ChevronsLeftIcon, {})
+                                ]
+                            }),
+                            /*#__PURE__*/ jsxs(Button, {
+                                variant: "outline",
+                                size: "icon-sm",
+                                onClick: ()=>table.previousPage(),
+                                disabled: !canPreviousPage,
+                                children: [
+                                    /*#__PURE__*/ jsx("span", {
+                                        className: "sr-only",
+                                        children: t("go_to_previous_page", {
+                                            defaultValue: "Go to previous page"
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(ChevronLeftIcon, {})
+                                ]
+                            }),
+                            /*#__PURE__*/ jsxs(Button, {
+                                variant: "outline",
+                                size: "icon-sm",
+                                onClick: ()=>table.nextPage(),
+                                disabled: !canNextPage,
+                                children: [
+                                    /*#__PURE__*/ jsx("span", {
+                                        className: "sr-only",
+                                        children: t("go_to_next_page", {
+                                            defaultValue: "Go to next page"
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(ChevronRightIcon, {})
+                                ]
+                            }),
+                            /*#__PURE__*/ jsxs(Button, {
+                                variant: "outline",
+                                size: "icon-sm",
+                                className: "hidden lg:flex",
+                                onClick: ()=>table.setPageIndex(pageCount - 1),
+                                disabled: !canNextPage,
+                                children: [
+                                    /*#__PURE__*/ jsx("span", {
+                                        className: "sr-only",
+                                        children: t("go_to_last_page", {
+                                            defaultValue: "Go to last page"
+                                        })
+                                    }),
+                                    /*#__PURE__*/ jsx(ChevronsRightIcon, {})
+                                ]
+                            })
+                        ]
+                    })
+                ]
+            })
+        ]
+    });
+}
+export { DataTablePagination };

package/dist/registry/data-table/data-table-row.d.ts

@@ -0,0 +1,6 @@
+import * as React from "react";
+import { TableCell, TableRow } from "../table/table";
+declare const DATA_TABLE_ROW_HEIGHT = "h-[52px]";
+declare function DataTableRow({ className, ...props }: React.ComponentProps<typeof TableRow>): import("react/jsx-runtime").JSX.Element;
+declare function DataTableCell({ className, ...props }: React.ComponentProps<typeof TableCell>): import("react/jsx-runtime").JSX.Element;
+export { DATA_TABLE_ROW_HEIGHT, DataTableRow, DataTableCell };