@genispace/geniapp 0.3.0 → 0.4.0

package/dist/components/internal/workbench/utils/chinaProvinceMap.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Chinese province name mapping constants
+ * Used for map chart data processing
+ * These are data mappings, not UI text
+ */
+export declare const PROVINCE_NAME_MAP: Record<string, string>;
+export declare const CHINESE_PROVINCE_NAMES: Record<string, string>;
+export declare const STANDARD_CHINESE_PROVINCE_NAMES: Record<string, string>;

package/dist/components/internal/workbench/utils/colors.d.ts

@@ -0,0 +1,84 @@
+export declare const TASK_STATUS_COLORS: {
+    readonly COMPLETED: "text-green-600 dark:text-green-400";
+    readonly FAILED: "text-destructive";
+    readonly TIMEOUT: "text-destructive";
+    readonly PENDING: "text-yellow-600 dark:text-yellow-400";
+    readonly RUNNING: "text-blue-600 dark:text-blue-400";
+    readonly RETRY: "text-orange-600 dark:text-orange-400";
+    readonly CANCELED: "text-muted-foreground";
+};
+export declare const TASK_STATUS_BG_COLORS: {
+    readonly COMPLETED: "bg-green-50 dark:bg-green-900/20 border-green-200 dark:border-green-800";
+    readonly FAILED: "bg-red-50 dark:bg-red-900/20 border-red-200 dark:border-red-800";
+    readonly TIMEOUT: "bg-red-50 dark:bg-red-900/20 border-red-200 dark:border-red-800";
+    readonly PENDING: "bg-yellow-50 dark:bg-yellow-900/20 border-yellow-200 dark:border-yellow-800";
+    readonly RUNNING: "bg-blue-50 dark:bg-blue-900/20 border-blue-200 dark:border-blue-800";
+    readonly RETRY: "bg-orange-50 dark:bg-orange-900/20 border-orange-200 dark:border-orange-800";
+    readonly CANCELED: "bg-muted border-muted-foreground/20";
+};
+export declare const SEMANTIC_COLORS: {
+    readonly text: {
+        readonly primary: "text-foreground";
+        readonly secondary: "text-muted-foreground";
+        readonly muted: "text-muted-foreground";
+        readonly error: "text-destructive";
+        readonly success: "text-green-600 dark:text-green-400";
+        readonly warning: "text-yellow-600 dark:text-yellow-400";
+        readonly info: "text-blue-600 dark:text-blue-400";
+    };
+    readonly background: {
+        readonly primary: "bg-background";
+        readonly secondary: "bg-muted";
+        readonly card: "bg-card";
+        readonly error: "bg-red-50 dark:bg-red-900/20";
+        readonly success: "bg-green-50 dark:bg-green-900/20";
+        readonly warning: "bg-yellow-50 dark:bg-yellow-900/20";
+        readonly info: "bg-blue-50 dark:bg-blue-900/20";
+    };
+    readonly border: {
+        readonly primary: "border-border";
+        readonly muted: "border-muted-foreground/20";
+        readonly error: "border-red-200 dark:border-red-800";
+        readonly success: "border-green-200 dark:border-green-800";
+        readonly warning: "border-yellow-200 dark:border-yellow-800";
+        readonly info: "border-blue-200 dark:border-blue-800";
+    };
+    readonly hover: {
+        readonly primary: "hover:bg-accent hover:text-accent-foreground";
+        readonly secondary: "hover:bg-muted";
+        readonly error: "hover:bg-red-100 dark:hover:bg-red-900/30 hover:text-red-600";
+        readonly success: "hover:bg-green-100 dark:hover:bg-green-900/30 hover:text-green-600";
+        readonly warning: "hover:bg-yellow-100 dark:hover:bg-yellow-900/30 hover:text-yellow-600";
+        readonly info: "hover:bg-blue-100 dark:hover:bg-blue-900/30 hover:text-blue-600";
+    };
+};
+export declare const ICON_COLORS: {
+    readonly folder: "text-blue-500 dark:text-neutral-400";
+    readonly file: "text-muted-foreground";
+    readonly success: "text-green-600 dark:text-green-400";
+    readonly error: "text-destructive";
+    readonly warning: "text-yellow-600 dark:text-yellow-400";
+    readonly info: "text-blue-600 dark:text-blue-400";
+    readonly loading: "text-muted-foreground";
+};
+export declare const PRIORITY_COLORS: {
+    readonly high: "text-red-600 dark:text-red-400";
+    readonly medium: "text-yellow-600 dark:text-yellow-400";
+    readonly low: "text-green-600 dark:text-green-400";
+    readonly normal: "text-muted-foreground";
+};
+export declare const CHART_CATEGORICAL_COLORS: readonly ["#6B8EBF", "#6FA68C", "#B89A6B", "#C7897D", "#8B86B3", "#5E9D9A", "#A08098", "#8FA66F", "#A69484", "#7E9BB5"];
+export declare const CHART_SEQUENCE_COLORS: readonly ["#6B8EBF", "#6FA68C", "#B89A6B", "#C7897D", "#8B86B3", "#5E9D9A", "#A08098", "#8FA66F", "#A69484", "#7E9BB5"];
+export declare const CHART_COLOR_SCHEME_IDS: readonly ["default", "vivid", "ocean", "sunset", "forest", "contrast", "logistics"];
+export declare const ECHARTS_CHART_COLOR_SCHEME_IDS: readonly ["default", "vivid", "ocean", "sunset", "forest", "contrast", "logistics"];
+export type ChartColorSchemeId = (typeof CHART_COLOR_SCHEME_IDS)[number];
+export type EChartsChartColorSchemeId = ChartColorSchemeId;
+export declare function normalizeChartColorSchemeId(schemeId: string | undefined): ChartColorSchemeId;
+export declare function resolveEchartsChartPalette(schemeId: string | undefined, customColors?: string[] | null): string[];
+export declare function getPresetChartColorSchemeColors(schemeId: string | undefined): string[];
+export declare const getTaskStatusIconColor: (status: string) => string;
+export declare const getTaskStatusTextColor: (status: string) => string;
+export declare const getTaskStatusBgColor: (status: string) => string;
+export type TaskStatus = keyof typeof TASK_STATUS_COLORS;
+export type SemanticColorType = keyof typeof SEMANTIC_COLORS;
+export type SemanticColorVariant = keyof typeof SEMANTIC_COLORS.text;

package/dist/components/internal/workbench/utils/componentUtils.d.ts

@@ -0,0 +1,4 @@
+export declare const COMPONENT_TYPE_NAMES: Record<string, string>;
+export declare const COMPONENT_TYPE_IDENTIFIERS: Record<string, string>;
+export declare const getComponentDisplayName: (componentType: string) => string;
+export declare const supportsLayoutEditing: (componentType: string) => boolean;

package/dist/components/internal/workbench/utils/conditionMapperUtils.d.ts

@@ -0,0 +1,59 @@
+export declare const getOperatorLabel: (operator: string) => string;
+export declare const getOperatorColor: (operator: string) => string;
+export declare const getEnhancedOperatorColor: (operator: string) => string;
+export declare const findRecommendedField: <T extends {
+    dataIndex?: string;
+    name?: string;
+}>(fields: T[], usedFields: string[]) => T | null;
+export declare const generateConditionDescription: (fieldName: string, condition: any) => string;
+export declare const OPERATOR_OPTIONS: readonly [{
+    readonly value: "equals";
+    readonly label: string;
+}, {
+    readonly value: "not_equals";
+    readonly label: string;
+}, {
+    readonly value: "in";
+    readonly label: string;
+}, {
+    readonly value: "not_in";
+    readonly label: string;
+}, {
+    readonly value: "like";
+    readonly label: string;
+}, {
+    readonly value: "between";
+    readonly label: string;
+}];
+export declare const SOURCE_OPTIONS: {
+    readonly BASIC: readonly [{
+        readonly value: "column";
+        readonly label: string;
+        readonly icon: "Table";
+    }, {
+        readonly value: "input_field";
+        readonly label: string;
+        readonly icon: "Database";
+    }, {
+        readonly value: "static";
+        readonly label: string;
+        readonly icon: "Database";
+    }, {
+        readonly value: "parameter";
+        readonly label: string;
+        readonly icon: "Settings";
+    }];
+    readonly ENHANCED: readonly [{
+        readonly value: "column";
+        readonly label: string;
+        readonly icon: "Table";
+    }, {
+        readonly value: "static";
+        readonly label: string;
+        readonly icon: "Database";
+    }, {
+        readonly value: "parameter";
+        readonly label: string;
+        readonly icon: "Settings";
+    }];
+};

package/dist/components/internal/workbench/utils/cssParser.d.ts

@@ -0,0 +1,7 @@
+import { CustomStylesConfig } from '../types/components';
+
+export declare function validateCss(cssCode: string): {
+    isValid: boolean;
+    errors: string[];
+};
+export declare function mergeStyleConfigs(base: CustomStylesConfig, override: Partial<CustomStylesConfig>): CustomStylesConfig;

package/dist/components/internal/workbench/utils/currencySymbol.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Currency symbol mapping -- the single site-wide definition point (finalized 2026-07-08).
+ * The data layer (ds_store_dim.currency / the `currency` field emitted by datasources) always
+ * stores currency CODES (CNY/HKD/...); symbol conversion is a presentation-layer concern and is
+ * maintained here only: to change the mapping, edit this one table.
+ * Unknown codes pass through as-is (e.g. 'USD2,300' -> just add it to the map) -- no blanket
+ * fallback to ¥, so mistakes stay visible and debuggable.
+ */
+export declare const CURRENCY_SYMBOLS: Record<string, string>;
+export declare const currencySymbol: (code: unknown) => string;

package/dist/components/internal/workbench/utils/dataConfigUtils.d.ts

@@ -0,0 +1,80 @@
+import { InsertDatasetConfig, UpdateDatasetConfig } from '../types';
+
+export declare function debugCurrentUser(): void;
+export declare function evaluateExpression(expression: string, formData: Record<string, any>, parameters: Record<string, any>): any;
+export declare function buildInsertDataFromConfig(insertFields: InsertDatasetConfig['insertFields'], formData: Record<string, any>, parameters?: Record<string, any>): Record<string, any>;
+export declare function buildUpdateDataFromConfig(updateFields: UpdateDatasetConfig['updateFields'], formData: Record<string, any>, parameters?: Record<string, any>): Record<string, any>;
+export declare function buildUpdateConditionsFromConfig(updateConditions: UpdateDatasetConfig['updateConditions'], formData: Record<string, any>, parameters?: Record<string, any>): Record<string, any>;
+export declare function buildDatabaseUpdateData(updateFields: Record<string, {
+    source: 'static' | 'parameter' | 'input_field' | 'column' | 'computed' | 'user';
+    value: string;
+    required?: boolean;
+    fieldType?: 'VARCHAR' | 'INT32' | 'FLOAT' | 'BOOL' | 'JSON' | 'DATETIME';
+    defaultValue?: any;
+    transform?: string;
+}>, rowData: Record<string, any>, parameters?: Record<string, any>): Record<string, any>;
+export declare function buildDatabaseUpdateConditions(updateConditions: Record<string, {
+    id?: string;
+    source: 'static' | 'parameter' | 'input_field' | 'column';
+    value: string;
+    operator?: 'equals' | 'not_equals' | 'in' | 'not_in' | 'like' | 'between';
+}>, rowData: Record<string, any>, parameters?: Record<string, any>): Record<string, any> | null;
+export interface DatasourceField {
+    name: string;
+    type: string;
+    title?: string;
+    description?: string;
+    required?: boolean;
+    format?: string;
+}
+export interface DatasourceSchema {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        title?: string;
+        description?: string;
+        format?: string;
+    }>;
+    required?: string[];
+}
+export declare function extractOutputSchemaProperties(outputSchema: Record<string, unknown> | null | undefined): Record<string, {
+    type?: string;
+    title?: string;
+    description?: string;
+    format?: string;
+    nullable?: boolean;
+}> | null;
+export declare function parseOutputSchemaFields(outputSchema: Record<string, unknown> | null | undefined): Array<{
+    name: string;
+    type: string;
+    title?: string;
+    description?: string;
+    format?: string;
+    nullable?: boolean;
+    required?: boolean;
+}>;
+export declare function mapSchemaFieldType(schemaType: string, format?: string): 'VARCHAR' | 'INT32' | 'FLOAT' | 'BOOL' | 'JSON' | 'DATETIME';
+export declare function getRecommendedOperators(fieldType: 'VARCHAR' | 'INT32' | 'FLOAT' | 'BOOL' | 'JSON' | 'DATETIME'): Array<'equals' | 'not_equals' | 'in' | 'not_in' | 'like' | 'between'>;
+export declare function validateFieldTypeCompatibility(fieldName: string, sourceType: string, targetType: 'VARCHAR' | 'INT32' | 'FLOAT' | 'BOOL' | 'JSON' | 'DATETIME'): {
+    valid: boolean;
+    message?: string;
+};
+export interface InputSchemaParameter {
+    name: string;
+    type: string;
+    title?: string;
+    description?: string;
+    required?: boolean;
+    defaultValue?: any;
+}
+export interface InputSchema {
+    type: 'object';
+    properties: Record<string, {
+        type: string;
+        title?: string;
+        description?: string;
+        format?: string;
+        default?: any;
+    }>;
+    required?: string[];
+}

package/dist/components/internal/workbench/utils/databaseDatasourceColumnValue.d.ts

@@ -0,0 +1,8 @@
+import { DatabaseDataSourceConfig } from '../types/databaseDataSource';
+
+export declare function queryDatabaseColumnValue(datasourceConfig: DatabaseDataSourceConfig, field: string, processedParams: Record<string, unknown>, condition?: string, opts?: {
+    nullAsEmpty?: boolean;
+}): Promise<{
+    result: number | string;
+    error?: string;
+}>;

package/dist/components/internal/workbench/utils/databaseDatasourceParams.d.ts

@@ -0,0 +1,44 @@
+import { ParameterRecord, ParameterValue } from '../types/parameters';
+
+export declare function extractParameterNamesFromDatasourceParameters(parameters: Record<string, unknown> | undefined): string[];
+/**
+ * Source names of bound params that carry a configured default `value` (including `''`).
+ * Such params always resolve to at least their default ('' = "no filter"), so they must NOT
+ * gate the first fetch. Otherwise a component that mounts AFTER the params were broadcast
+ * (e.g. a lazy tab with `destroyInactiveTabPane: true`) waits forever for an already-passed
+ * broadcast and never fetches — the table shows up empty. Only genuinely-required bound params
+ * (declared without a default) should gate.
+ */
+export declare function extractDefaultedParameterNamesFromDatasourceParameters(parameters: Record<string, unknown> | undefined): string[];
+/**
+ * Fetch-gate groups for a datasource's bound parameters, per the `waitForValue` contract
+ * (editable in DatabaseDataSourceEditor's "wait for value" toggle):
+ * - `waitForValue: false` → never gates the first fetch (optional dimension).
+ * - `waitForValue: true`  → `strict`: the first fetch MUST wait until the param has an actual
+ *   value on the bus. Readiness marks alone don't count — FilterPanel marks its params ready
+ *   before async-resolved values (e.g. preset date ranges) land, which is exactly what used to
+ *   let empty-date queries through (all-time data overwriting the correct response).
+ * - absent → `legacy`: gates only when the param has NO configured default `value` (a default —
+ *   including `''` = "no filter" — self-resolves; waiting on it would stall components that
+ *   mount after the broadcast, e.g. lazy tabs). Readiness escapes stay valid for these.
+ * A source bound in several entries lands in the strictest group that claims it.
+ */
+export interface DatasourceFetchGateParams {
+    strict: string[];
+    legacy: string[];
+    all: string[];
+}
+export declare function extractFetchGateParamsFromDatasourceParameters(parameters: Record<string, unknown> | undefined): DatasourceFetchGateParams;
+/**
+ * Config KEYS (request-body field names, not bus source names) of bindings with an explicit
+ * `waitForValue: true`. For renderers that gate on the RESOLVED request body (Chart/Form/Tree/
+ * CollapsePanel style, where the body is a render-time memo): the fetch may only go out once
+ * every strict key actually resolved to a value — checking the body itself keeps gate and
+ * payload coherent by construction.
+ */
+export declare function extractStrictWaitParameterKeysFromDatasourceParameters(parameters: Record<string, unknown> | undefined): string[];
+export declare function hasResolvedDatasourceParameterValues(parameterNames: string[], getCurrentParameter: (name: string) => ParameterValue | undefined, rawParams: ParameterRecord): boolean;
+export declare function convertDatasourceParameterValue(value: unknown, type: string): unknown;
+export declare function processDataSourceParametersForQuery(parameters: Record<string, unknown> | undefined, parameterTypes: Record<string, string> | undefined, getCurrentParameter: (name: string) => ParameterValue | undefined, rawParams: ParameterRecord): Record<string, unknown>;
+export declare function extractParameterNamesFromCondition(condition: string | undefined): string[];
+export declare function replaceParametersInConditionString(condition: string | undefined, getCurrentParameter: (name: string) => ParameterValue | undefined, rawParams: ParameterRecord): string | undefined;

package/dist/components/internal/workbench/utils/datasetOperationUtils.d.ts

@@ -0,0 +1,48 @@
+import { ParameterRecord } from '../types/parameters';
+import { TableDataType } from '../types/renderers';
+
+interface FieldMappingConfig {
+    source: string;
+    value: string;
+    fieldType?: string;
+    required?: boolean;
+}
+export declare function resolveTargetDatasetId(targetDatasetId: string | {
+    source: 'parameter' | 'static';
+    paramName?: string;
+    value?: string;
+}, parameters: ParameterRecord, pageParams?: ParameterRecord): string;
+export declare function executeDatasetOperation(operationType: 'update' | 'insert' | 'delete', config: {
+    targetDatasetId: string | {
+        source: 'parameter' | 'static';
+        paramName?: string;
+        value?: string;
+    };
+    updateFields?: Record<string, FieldMappingConfig & {
+        source?: string;
+    }>;
+    insertFields?: Record<string, FieldMappingConfig & {
+        source?: string;
+    }>;
+    updateConditions?: Record<string, FieldMappingConfig & {
+        source?: string;
+    }>;
+    deleteConditions?: Record<string, FieldMappingConfig & {
+        source?: string;
+    }>;
+}, record: TableDataType, parameters?: ParameterRecord, pageParams?: ParameterRecord, formValues?: Record<string, unknown>): Promise<import('../lib/types/api').ApiResponse<{
+    deletedCount?: number;
+    deleted_count?: number;
+    affectedRows?: number;
+    affected_rows?: number;
+}> | import('../lib/types/api').ApiResponse<{
+    updatedCount?: number;
+    updated_count?: number;
+    affectedRows?: number;
+    affected_rows?: number;
+}> | import('../lib/types/api').ApiResponse<{
+    ids?: Array<string | number>;
+    insertedCount?: number;
+    inserted_count?: number;
+}>>;
+export {};

package/dist/components/internal/workbench/utils/datasourceVersion.d.ts

@@ -0,0 +1,61 @@
+import { WorkbenchConfigData } from '../types';
+
+/**
+ * Workbench-level datasource version pins.
+ *
+ * `config.datasourceVersions` is a sparse `{ [datasourceId]: version }` map:
+ * a missing entry means "follow the datasource default version". Runtime
+ * priority: workbench map > component/action-level version field > default.
+ *
+ * Renderers and hooks deep inside the tree do not receive the workbench
+ * config, so the layout syncs the map into a module-level registry
+ * (`setRuntimeDatasourceVersions`); call sites resolve through
+ * `resolveRuntimeDatasourceVersion` (imperative) or `useDatasourceVersions`
+ * (reactive).
+ */
+type DatasourceVersionsMap = Record<string, number>;
+/** Pure resolver per the design doc: read the map, fall back to the caller's version. */
+export declare function resolveDatasourceVersion(config: Pick<WorkbenchConfigData, 'datasourceVersions'> | null | undefined, datasourceId: string | null | undefined, fallback?: number): number | undefined;
+/** Called by WorkbenchLayout whenever the loaded/draft config changes. */
+export declare function setRuntimeDatasourceVersions(versions: DatasourceVersionsMap | undefined): void;
+export declare function getRuntimeDatasourceVersions(): DatasourceVersionsMap | undefined;
+/** Imperative resolution for event-driven call sites (actions, exports, caches). */
+export declare function resolveRuntimeDatasourceVersion(datasourceId: string | null | undefined, fallback?: number): number | undefined;
+/** Reactive read: components refetch when a pin changes. */
+export declare function useDatasourceVersions(): DatasourceVersionsMap | undefined;
+/**
+ * Sync the workbench-level pins from the loaded config into the module registry,
+ * clearing on unmount. Shared by every layout entry (desktop WorkbenchLayout and
+ * WorkbenchMobileLayout) so no viewport-specific entry can forget to populate it.
+ */
+export declare function useSyncRuntimeDatasourceVersions(config: Pick<WorkbenchConfigData, 'datasourceVersions'> | null | undefined): void;
+/**
+ * F6 fallback detection: backend `resolveDataSourceConfig(id, spaceId, version=N)`
+ * throws 404 `DATASOURCE_VERSION_NOT_FOUND` when the pinned version was deleted.
+ * BaseApiClient attaches the response body as `errorDetails`.
+ */
+export declare function isDatasourceVersionNotFoundError(error: unknown): boolean;
+export interface ReferencedDatasource {
+    datasourceId: string;
+    /** Name carried by the workbench config (databaseDataSourceConfig.datasourceName). */
+    name?: string;
+}
+/**
+ * All datasources referenced by the workbench — deduplicated, with the config-carried
+ * datasourceName when present. Deep-walks `config.pages` only.
+ *
+ * Reference shapes collected:
+ *  - component `databaseDataSourceConfig.datasourceId` (root-level or under props) — carries the name;
+ *  - action `targetDatasourceId` (update/insert/delete/transaction);
+ *  - ANY plain `{ datasourceId: string }` own property — catches FilterPanel-internal sources that
+ *    live outside databaseDataSourceConfig: filter option `dataSource`, presetDateRange
+ *    `dateRangeSource` / `customTabs[].source`, `updateTime`, filterSheet section/tab/tag sources, …;
+ *  - `{ stampDatasourceId: string }` (FilterPanel option-cache stamp meta source).
+ */
+export declare function collectReferencedDatasources(config: Pick<WorkbenchConfigData, 'pages'> | null | undefined): ReferencedDatasource[];
+/**
+ * All datasource ids referenced by the workbench — deduplicated.
+ * Convenience wrapper over collectReferencedDatasources.
+ */
+export declare function collectReferencedDatasourceIds(config: Pick<WorkbenchConfigData, 'pages'> | null | undefined): string[];
+export {};

package/dist/components/internal/workbench/utils/debugUtils.d.ts

@@ -0,0 +1,34 @@
+export interface DebugInfo {
+    timestamp: number;
+    type: 'parameter_change' | 'component_render' | 'navigation' | 'error';
+    component?: string;
+    tabId?: string;
+    pageId?: string;
+    details: any;
+}
+declare class DebugLogger {
+    private logs;
+    private maxLogs;
+    private isEnabled;
+    log(type: DebugInfo['type'], details: any, component?: string, tabId?: string, pageId?: string): void;
+    getLogs(filter?: Partial<Pick<DebugInfo, 'type' | 'component' | 'tabId' | 'pageId'>>): DebugInfo[];
+    clear(): void;
+    getStats(): {
+        total: number;
+        byType: Record<string, number>;
+        byComponent: Record<string, number>;
+        byTab: Record<string, number>;
+    };
+}
+export declare const debugLogger: DebugLogger;
+export declare const logParameterChange: (key: string, value: any, oldValue: any, source: string, componentId?: string, tabId?: string) => void;
+export declare const logComponentRender: (componentId: string, componentType: string, renderProps: any, tabId?: string, pageId?: string) => void;
+export declare const logNavigation: (from: string, to: string, tabId?: string, pageId?: string) => void;
+export declare const logError: (error: Error, context: string, componentId?: string, tabId?: string, pageId?: string) => void;
+export declare const createPerformanceMonitor: (name: string) => {
+    end: () => number;
+};
+export declare const detectRenderingStateUpdates: () => void;
+export declare const setupGlobalErrorHandling: () => void;
+export declare const initDebugTools: () => void;
+export {};

package/dist/components/internal/workbench/utils/errorFilter.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/components/internal/workbench/utils/errorHandler.d.ts

@@ -0,0 +1,10 @@
+export interface ApiError {
+    message: string;
+    code?: string;
+    status?: number;
+    originalError?: unknown;
+}
+export declare const extractApiError: (error: unknown, namespaceHint?: string) => ApiError;
+export declare const getFriendlyErrorMessage: (error: ApiError, context?: string, namespaceHint?: string) => string;
+export declare const getErrorTitle: (error: ApiError) => string;
+export declare const handleApiError: (error: unknown, context?: string, namespaceHint?: string) => ApiError;

package/dist/components/internal/workbench/utils/expressionUtils.d.ts

@@ -0,0 +1,13 @@
+export interface UserInfo {
+    id?: string;
+    name?: string;
+    email?: string;
+}
+export declare function evaluateComputedExpression(expression: string, userInfo?: UserInfo): string;
+export declare function getComputedExpressionTemplates(): {
+    label: string;
+    value: string;
+    description: string;
+    example: string;
+    category: string;
+}[];

package/dist/components/internal/workbench/utils/extensionErrorHandler.d.ts

@@ -0,0 +1,4 @@
+export declare const isExtensionError: (error: Error | string) => boolean;
+export declare const handleExtensionError: (error: Error) => void;
+export declare const setupExtensionErrorHandler: () => void;
+export declare const diagnoseExtensionIssues: () => void;

package/dist/components/internal/workbench/utils/filterPanelDateRangeUtils.d.ts

@@ -0,0 +1,34 @@
+export type DateRangeQuickSelectPresetKey = 'today' | 'yesterday' | 'yesterdayToToday' | 'last7days' | 'last30days';
+export type DateRangeQuickSelectItems = Partial<Record<DateRangeQuickSelectPresetKey, boolean>>;
+export type DateRangeDefaultConfig = {
+    type: string;
+    defaultValue?: unknown;
+    useSpecifiedTime?: boolean;
+    showTimePicker?: boolean;
+    specifiedStartTime?: string;
+    specifiedEndTime?: string;
+    quickSelectItems?: DateRangeQuickSelectItems;
+};
+export type TimeParts = {
+    h: number;
+    m: number;
+    s: number;
+};
+export declare function parseTimePartsFromConfig(value: string | undefined): TimeParts | undefined;
+export declare function combineDateWithTimeParts(d: Date, parts: TimeParts): Date;
+export declare function applyConfiguredTimeToDateRange(filter: DateRangeDefaultConfig, range: {
+    from: Date;
+    to: Date;
+}): {
+    from: Date;
+    to: Date;
+};
+export declare function formatDateRangeStartForParams(filter: DateRangeDefaultConfig, from: Date): string;
+export declare function formatDateRangeEndForParams(filter: DateRangeDefaultConfig, to: Date): string;
+export declare function resolveDateRangeDefault(filter: DateRangeDefaultConfig): {
+    from: Date;
+    to: Date;
+} | undefined;
+export declare function filterConfigKeyForReset(f: DateRangeDefaultConfig & {
+    key: string;
+}): string;

package/dist/components/internal/workbench/utils/filterPanelMobileDateRangeUtils.d.ts

@@ -0,0 +1,17 @@
+import { DateRange } from 'react-day-picker';
+import { TFunction } from 'i18next';
+import { DateRangeDefaultConfig, DateRangeQuickSelectPresetKey, DateRangeQuickSelectItems } from './filterPanelDateRangeUtils';
+
+export type DateRangeSelectionMode = DateRangeQuickSelectPresetKey | 'custom';
+export declare const DATE_RANGE_PRESET_ORDER: DateRangeQuickSelectPresetKey[];
+export declare function isQuickPresetVisible(preset: DateRangeQuickSelectPresetKey, quickSelectItems?: DateRangeQuickSelectItems): boolean;
+export declare function getVisibleDateRangePresets(quickSelectItems?: DateRangeQuickSelectItems): DateRangeQuickSelectPresetKey[];
+export declare function buildDateRangeForPreset(preset: DateRangeQuickSelectPresetKey): {
+    from: Date;
+    to: Date;
+};
+export declare function areDateRangesEqual(a?: DateRange, b?: DateRange): boolean;
+export declare function matchDateRangeToPreset(range: DateRange | undefined, filter: DateRangeDefaultConfig, quickSelectItems?: DateRangeQuickSelectItems): DateRangeSelectionMode;
+export declare function getDateRangePresetLabel(preset: DateRangeQuickSelectPresetKey, t: TFunction): string;
+export declare function getCustomDateRangeLabel(t: TFunction): string;
+export declare function formatMobileDateRangeSummary(range: DateRange | undefined, mode: DateRangeSelectionMode, t: TFunction, dateFormatPattern?: string): string;

package/dist/components/internal/workbench/utils/formActionVisibility.d.ts

@@ -0,0 +1,21 @@
+import { FormActionVisibility, FormActionVisibilityClause, FormActionVisibilityOperator, VisibilityCondition } from '../types';
+
+/** Minimal shape required by visibility-clause helpers. FormAction and TableAction both satisfy it. */
+type FormActionLike = {
+    actionVisibility?: FormActionVisibility;
+    visibilityCondition?: VisibilityCondition;
+};
+export declare function normalizeFormActionVisibilityClauses(action: FormActionLike): FormActionVisibilityClause[];
+export declare function collectFormFieldKeysFromFormActionVisibility(actions: (FormActionLike & {
+    id?: string;
+})[] | undefined): Set<string>;
+export declare function hasFormActionParameterVisibilityClauses(actions: FormActionLike[] | undefined): boolean;
+export declare function evaluateFormActionVisibility(action: FormActionLike, context: {
+    formValues: Record<string, unknown>;
+    parameters: Record<string, unknown>;
+}): boolean;
+export declare function stableSerializePageParams(pageParams: Record<string, unknown> | undefined): string;
+/** Parse compare value for editor: IN uses JSON array or comma-separated tokens. */
+export declare function parseVisibilityCompareValue(operator: FormActionVisibilityOperator, raw: string): unknown;
+export declare function formatVisibilityCompareValueForEditor(operator: FormActionVisibilityOperator, value: unknown): string;
+export {};