@genispace/geniapp 0.3.0 → 0.5.0

package/dist/components/renderers/service-desk/ServiceDeskReporterRenderer.d.ts

@@ -0,0 +1,48 @@
+export interface ServiceDeskReporterProps {
+    applicationId?: string;
+    intakeDatasourceId?: string;
+    submitDatasourceId?: string;
+    myTicketsDatasourceId?: string;
+    requesterDetailDatasourceId?: string;
+    addActivityDatasourceId?: string;
+    requesterActionDatasourceId?: string;
+    title?: string;
+    description?: string;
+    submitButtonText?: string;
+    showRecentTickets?: boolean;
+    allowAttachments?: boolean;
+    maxFiles?: number;
+    maxFileSizeMb?: number;
+    acceptedFileTypes?: string;
+    defaultCategoryId?: string;
+    defaultImpact?: 'high' | 'medium' | 'low';
+    defaultUrgency?: 'high' | 'medium' | 'low';
+    contextParams?: Array<{
+        pageParam: string;
+        contextKey: string;
+    }>;
+    /** @deprecated Use contextParams instead. Kept as fallback for existing pages. */
+    contextStoreParam?: string;
+    /** @deprecated Use contextParams instead. Kept as fallback for existing pages. */
+    contextBrandParam?: string;
+    /** @deprecated Use contextParams instead. Kept as fallback for existing pages. */
+    contextDashboardParam?: string;
+    /** @deprecated Use contextParams instead. Kept as fallback for existing pages. */
+    contextWidgetParam?: string;
+    pageParams?: Record<string, unknown>;
+}
+declare function rowsFromResponse(response: unknown): Record<string, unknown>[];
+declare function accessCodes(response: unknown): string[];
+type StatusTranslate = (key: string, fallback: string) => string;
+declare function statusLabel(state: string, t?: StatusTranslate): string;
+declare function relatedRecordStatusLabel(state?: string | null, fallback?: string | null, t?: StatusTranslate): string;
+declare function parseJsonField<T>(value: unknown, fallback: T): T;
+export default function ServiceDeskReporterRenderer(props: ServiceDeskReporterProps): import("react").JSX.Element;
+export declare const serviceDeskReporterTestUtils: {
+    accessCodes: typeof accessCodes;
+    parseJsonField: typeof parseJsonField;
+    relatedRecordStatusLabel: typeof relatedRecordStatusLabel;
+    rowsFromResponse: typeof rowsFromResponse;
+    statusLabel: typeof statusLabel;
+};
+export {};

package/dist/components/renderers/service-desk/index.d.ts

@@ -0,0 +1 @@
+export { default as ServiceDeskReporterRenderer } from './ServiceDeskReporterRenderer';

package/dist/components/renderers/service-desk.js

@@ -0,0 +1,5 @@
+import { aZ as o } from "./runtime-DX1LfmqO.js";
+export {
+  o as ServiceDeskReporterRenderer
+};
+//# sourceMappingURL=service-desk.js.map

package/dist/components/renderers/service-desk.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"service-desk.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/components/renderers/shared/TableEmptyStateWithChromeInsets.d.ts

@@ -0,0 +1,12 @@
+import { ComponentProps } from 'react';
+import { TableEmptyState } from '../../skeleton';
+
+type TableEmptyStateBaseProps = ComponentProps<typeof TableEmptyState>;
+export interface TableEmptyStateWithChromeInsetsProps extends TableEmptyStateBaseProps {
+    /** When true with floatBadge, keep the badge clear of mobile sticky header / bottom nav. */
+    avoidMobileChrome?: boolean;
+    /** Re-measure chrome insets when this changes (e.g. empty state becomes visible). */
+    chromeRemeasureKey?: unknown;
+}
+export declare function TableEmptyStateWithChromeInsets({ avoidMobileChrome, chromeRemeasureKey, floatBadge, ...rest }: TableEmptyStateWithChromeInsetsProps): import("react").JSX.Element;
+export {};

package/dist/components/renderers/shared/ViewToggleButton.d.ts

@@ -0,0 +1,13 @@
+import { default as React } from 'react';
+
+export type ViewType = 'chart' | 'data';
+interface ViewToggleButtonProps {
+    viewType: ViewType;
+    onToggle: () => void;
+    className?: string;
+    /** Desktop uses text labels; mobile defaults to a single icon toggle. */
+    variant?: 'text' | 'icon' | 'auto';
+}
+/** Chart / List shared header toggle — matches ChartRenderer & EChartsChartRenderer. */
+export declare const ViewToggleButton: React.FC<ViewToggleButtonProps>;
+export {};

package/dist/components/renderers/shared/useEscapedStickyPanel.d.ts

@@ -0,0 +1,6 @@
+import { ReactElement, ReactNode } from 'react';
+
+export declare function useEscapedStickyPanel(enabled: boolean, stickyTop?: string): {
+    wrapSticky: (panel: ReactElement) => ReactNode;
+    stuck: boolean;
+};

package/dist/components/renderers/shared/useMobileChromeInsets.d.ts

@@ -0,0 +1,18 @@
+export interface MobileChromeInsets {
+    /** Viewport px occupied by sticky/fixed chrome at the TOP (sticky FilterPanel or mobile header). */
+    top: number;
+    /** Viewport px occupied by fixed chrome at the BOTTOM (the bottom tab nav). */
+    bottom: number;
+}
+/**
+ * Mobile-only: measure the viewport insets taken by fixed/sticky workbench chrome — the sticky
+ * FilterPanel (falling back to the mobile header) at the top and the fixed bottom tab nav at the
+ * bottom. Pass the result to a floating element (e.g. {@link TableEmptyState}'s `floatBadge`) so it
+ * stays inside the content area instead of overlapping that chrome.
+ *
+ * Both values are 0 when `enabled` is false (e.g. desktop). The chrome sits at stable viewport
+ * positions, so we only re-measure on mount, on resize, and whenever `remeasureKey` changes — pass
+ * the "is the floating element visible" flag so insets are refreshed right when they are needed
+ * (the FilterPanel may not be sticky-positioned yet at first mount).
+ */
+export declare function useMobileChromeInsets(enabled: boolean, remeasureKey?: unknown): MobileChromeInsets;

package/dist/components/renderers/shared/useStickyHeaderClone.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Page-level sticky table header for MOBILE, without losing horizontal scroll.
+ *
+ * Why a clone: a table that scrolls horizontally lives inside an `overflow-x:auto`
+ * wrapper. Per CSS, that wrapper is also the vertical scroll container, so a plain
+ * `position: sticky` <thead> can only pin inside that wrapper — never to the page.
+ * So we render a lightweight CLONE of the real <thead> OUTSIDE the horizontal
+ * scroller: `position: sticky; top: var(--wb-filter-sticky-height)` pins it to the
+ * page scrollport right below the sticky FilterPanel; we sync its horizontal offset
+ * to the body's scrollLeft and mirror column widths. (This is what antd's
+ * `Table sticky={{ offsetHeader }}` does under the hood.)
+ *
+ * The hook is markup-agnostic: give it an empty overlay <div> rendered as the first
+ * child of the table card (before the scroll container). It finds the card's <table>
+ * + <thead> + horizontal scroller itself, clones the header, and keeps it in sync.
+ * Frozen/sticky-left columns keep working for free because the clone preserves the
+ * real header cells' classes/inline styles inside its own horizontal scroll context.
+ *
+ * Desktop (enabled=false) is a complete no-op: no clone, no observers, no listeners.
+ */
+export interface UseStickyHeaderCloneArgs {
+    /** Enable only on mobile (e.g. useMobileViewport().isMobile && tableViewIsActive). */
+    enabled: boolean;
+    /** Empty div rendered as the FIRST child of the table card, before the scroll container. */
+    overlayRef: React.RefObject<HTMLDivElement | null>;
+    /** Change this to force a full re-clone (columns identity / language / header font / view). */
+    cloneKey?: unknown;
+    /** CSS var consumed as the pin offset. Defaults to the FilterPanel height var. */
+    offsetVar?: string;
+}
+export declare function useStickyHeaderClone({ enabled, overlayRef, cloneKey, offsetVar, }: UseStickyHeaderCloneArgs): void;

package/dist/components/renderers/statistics/StatisticGroup.d.ts

@@ -0,0 +1,77 @@
+import { default as React } from 'react';
+import { DatabaseDataSourceConfig } from '../../types/databaseDataSource';
+import { ComponentParameterConfig } from '../../types/parameters';
+
+interface StatisticItemProps {
+    key: string;
+    title: string;
+    value: number | string;
+    precision?: number;
+    prefix?: string;
+    suffix?: string;
+    icon?: string;
+    iconSize?: number;
+    color?: string;
+    iconColor?: string;
+    valueColor?: string;
+    loading?: boolean;
+    valueStyle?: React.CSSProperties;
+    statisticType?: 'manual' | 'count' | 'sum' | 'avg' | 'max' | 'min' | 'column';
+    statisticField?: string;
+    statisticCondition?: string;
+    datasetId?: string;
+    databaseDataSourceConfig?: DatabaseDataSourceConfig | null;
+    useCustomDataSource?: boolean;
+    error?: string;
+    format?: 'currency-compact' | 'compact-k' | 'percent' | 'number';
+    currency?: string;
+    accent?: boolean;
+    warnBelow?: number;
+    warnText?: string;
+    /** Render an em dash instead of a fake 0 when the column value is NULL / missing (e.g. WoS pending upstream data). */
+    emptyDash?: boolean;
+    valueKind?: 'trend';
+    subText?: string;
+    trend?: {
+        enabled?: boolean;
+        trendCondition?: string;
+        suffix?: string;
+        description?: string;
+        upStyle?: 'success' | 'warning' | 'error';
+        downStyle?: 'success' | 'warning' | 'error';
+        value?: number;
+        type?: 'up' | 'down';
+        status?: 'success' | 'warning' | 'error';
+        error?: string;
+    };
+}
+interface StatisticGroupProps {
+    items?: StatisticItemProps[];
+    loading?: boolean;
+    className?: string;
+    useMockData?: boolean;
+    mockData?: StatisticItemProps[];
+    grid?: {
+        cols?: number;
+        gutter?: number | string | [number | string, number | string];
+    };
+    itemStyle?: {
+        padding?: string;
+        height?: string | number;
+        titleStyle?: React.CSSProperties;
+        valueStyle?: React.CSSProperties;
+    };
+    databaseDataSourceConfig?: DatabaseDataSourceConfig | null;
+    componentParameterConfig?: ComponentParameterConfig;
+    componentId?: string;
+    pageId?: string;
+    tabId?: string;
+    pageParams?: Record<string, any>;
+    onParameterChange?: (key: string, value: any) => void;
+    followPageRefresh?: boolean;
+    titleFontSize?: number;
+    valueFontSize?: number;
+    labelFontSize?: number;
+}
+declare const StatisticGroup: React.FC<StatisticGroupProps>;
+export default StatisticGroup;

package/dist/components/renderers/statistics/index.d.ts

@@ -0,0 +1 @@
+export { default as StatisticGroupRenderer } from './StatisticGroup';

package/dist/components/renderers/statistics.js

@@ -0,0 +1,5 @@
+import { a$ as t } from "./runtime-DX1LfmqO.js";
+export {
+  t as StatisticGroupRenderer
+};
+//# sourceMappingURL=statistics.js.map

package/dist/components/renderers/statistics.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"statistics.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/components/renderers/table/TableRenderer.d.ts

@@ -0,0 +1,5 @@
+import { default as React } from 'react';
+import { TableRendererProps } from '../../types/renderers';
+
+declare const TableRenderer: React.FC<TableRendererProps>;
+export default TableRenderer;

package/dist/components/renderers/table/index.d.ts

@@ -0,0 +1 @@
+export { default as TableRenderer } from './TableRenderer';

package/dist/components/renderers/table/tableFilterPanelGridClass.d.ts

@@ -0,0 +1,15 @@
+import { FilterPanelGridColumnCount, FilterPanelGridColumns } from '../../types/renderers';
+
+/**
+ * Merges saved props with layout defaults: base=1, md=3 (legacy TableRenderer behavior).
+ * Optional `sm` / `lg` / `xl` are only applied when set.
+ */
+export declare function mergeFilterPanelGridColumns(cols?: FilterPanelGridColumns): {
+    base: FilterPanelGridColumnCount;
+    sm: FilterPanelGridColumnCount;
+    md: FilterPanelGridColumnCount;
+    lg: FilterPanelGridColumnCount;
+    xl: FilterPanelGridColumnCount;
+};
+/** Full Tailwind class list for the filter field grid. */
+export declare function getFilterPanelGridClassName(cols?: FilterPanelGridColumns, narrowFlow?: boolean): string;

package/dist/components/renderers/table.js

@@ -0,0 +1,5 @@
+import { b0 as a } from "./runtime-DX1LfmqO.js";
+export {
+  a as TableRenderer
+};
+//# sourceMappingURL=table.js.map

package/dist/components/renderers/table.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"table.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/components/renderers/tabs/TabsRenderer.d.ts

@@ -0,0 +1,63 @@
+import { default as React } from 'react';
+import { ParameterRecord } from '../../types/parameters';
+import { Grid24LayoutConfig } from '../../types/components';
+import { VisibleWhen } from '../../utils/visibleWhen';
+
+interface TabItem {
+    key: string;
+    label: any;
+    visibleWhen?: VisibleWhen;
+    icon?: string;
+    disabled?: boolean;
+    closable?: boolean;
+    badge?: string | number;
+    children?: React.ReactNode;
+    component?: any;
+    components?: any[];
+    render?: () => React.ReactNode;
+    layout?: Grid24LayoutConfig;
+    componentConfig?: {
+        type: 'single' | 'multiple';
+        data?: any;
+        props?: Record<string, any>;
+    };
+}
+interface TabsRendererProps {
+    items: TabItem[];
+    defaultActiveKey?: string;
+    className?: string;
+    tabPosition?: 'top' | 'bottom' | 'left' | 'right';
+    type?: 'line' | 'card' | 'editable-card' | 'pill' | 'boxed' | 'vertical-line';
+    size?: 'small' | 'default' | 'large';
+    /** Vertical gap between tab bar and tab panel content. Number = px, or CSS length */
+    tabBarToContentGap?: string | number;
+    /**
+     * When true (default), the Tabs renderer wraps its content in a white
+     * rounded card with padding so the tab strip looks like a self-contained
+     * container. When false, the outer card chrome (background, padding,
+     * rounded corners) is dropped so the tab strip visually merges with the
+     * surrounding layout — useful when the parent already provides its own
+     * container chrome (e.g. a Card, or a panel that should appear
+     * flush with the tab content below).
+     */
+    showBorder?: boolean;
+    onChange?: (activeKey: string) => void;
+    onEdit?: (action: 'add' | 'remove', targetKey?: string) => void;
+    appConfig?: Record<string, unknown>;
+    pageParams?: ParameterRecord;
+    pageId?: string;
+    tabId?: string;
+    id?: string;
+    customStyles?: any;
+    loading?: boolean;
+    /** Section title font size (px). Default 14. */
+    titleFontSize?: number;
+    /** Tab trigger label font size (px). Default 14. */
+    labelFontSize?: number;
+    /** Tab badge font size (px). Default 13. */
+    badgeFontSize?: number;
+    [key: string]: any;
+    nestingLevel?: number;
+}
+declare const TabsRenderer: React.FC<TabsRendererProps>;
+export default TabsRenderer;

package/dist/components/renderers/tabs/index.d.ts

@@ -0,0 +1 @@
+export { default as TabsRenderer } from './TabsRenderer';

package/dist/components/renderers/tabs/tabVariantStyles.d.ts

@@ -0,0 +1,50 @@
+/**
+ * Tab variant definitions for the Tabs renderer.
+ *
+ * Each variant is the source of truth for both the runtime Tabs renderer
+ * (`TabsRenderer.tsx`) and the property-editor preview cards
+ * (`TabsPropertyEditor.tsx`). Every Tailwind utility referenced here is
+ * written as a complete string literal so the JIT content scanner picks
+ * them up and ships them in the final CSS bundle.
+ *
+ * Seven variants, intentionally visually distinct so they can be told apart
+ * at a glance (card/editable-card share the rail but differ in triggers;
+ * vertical-line intentionally reuses `line` for horizontal orientation):
+ *   - `line`:           underline-style tabs (no pill background)
+ *   - `card`:           segmented-pill tabs (single, immutable tab strip)
+ *   - `editable-card`:  segmented-pill tabs with per-tab × close button
+ *                       and a trailing "+ Add" button for adding tabs
+ *   - `pill`:           each tab is its own floating rounded pill,
+ *                       no shared container
+ *   - `boxed`:          tabs sit on top of a bordered container; the
+ *                       active tab "punches through" the bottom border
+ *                       so the tab appears connected to the panel below
+ *   - `segmented`:      full-width iOS-style segmented control — grey
+ *                       rounded rail, equal-width segments, active
+ *                       segment lifts to a white card with indigo text
+ *   - `vertical-line`:  underline-style for top/bottom tabPosition,
+ *                       flips to a left vertical line for left/right
+ *                       tabPosition so vertical tab strips no longer
+ *                       look like a misplaced horizontal underline
+ */
+export type TabVariant = 'line' | 'card' | 'editable-card' | 'pill' | 'boxed' | 'segmented' | 'vertical-line';
+export type TabOrientation = 'horizontal' | 'vertical';
+export declare const DEFAULT_TAB_VARIANT: TabVariant;
+export declare const TAB_VARIANTS: ReadonlyArray<TabVariant>;
+export interface TabVariantClasses {
+    /** Class string applied to the TabsList container. */
+    list: string;
+    /**
+     * Class string applied to each TabsTrigger. Variant-specific active-state
+     * styling is folded in via `data-[state=active]:*` selectors so consumers
+     * don't need to switch classes when active state changes.
+     */
+    trigger: string;
+    /** Class string for the × close button rendered on editable-card tabs. */
+    closableButton: string;
+    /** Class string for the trailing "+ Add" button on editable-card tabs. */
+    addButton: string;
+}
+export declare function normalizeTabVariant(type?: string | null): TabVariant;
+export declare function resolveTabVariantClasses(type?: string | null, orientation?: TabOrientation): TabVariantClasses;
+export declare function isEditableTabVariant(type?: string | null): boolean;

package/dist/components/renderers/tabs/tabsItemMapping.d.ts

@@ -0,0 +1,26 @@
+import { ReactNode } from 'react';
+import { VisibleWhen } from '../../utils/visibleWhen';
+import { Grid24LayoutConfig } from '../../types/components';
+
+/** Tab item shape stored on Tabs component props.items */
+export interface TabsConfigItem {
+    key: string;
+    label: unknown;
+    visibleWhen?: VisibleWhen;
+    icon?: string;
+    disabled?: boolean;
+    closable?: boolean;
+    badge?: string | number;
+    children?: ReactNode;
+    component?: unknown;
+    components?: unknown[];
+    render?: () => ReactNode;
+    componentConfig?: {
+        type: 'single' | 'multiple';
+        data?: unknown;
+        props?: Record<string, unknown>;
+    };
+    layout?: Grid24LayoutConfig;
+}
+/** Pass through tab item fields needed at runtime (avoid dropping visibleWhen, icon, etc.). */
+export declare function mapTabsConfigItemsForRenderer(items: TabsConfigItem[]): TabsConfigItem[];

package/dist/components/renderers/tabs.js

@@ -0,0 +1,5 @@
+import { b1 as a } from "./runtime-DX1LfmqO.js";
+export {
+  a as TabsRenderer
+};
+//# sourceMappingURL=tabs.js.map

package/dist/components/renderers/tabs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tabs.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/components/renderers/task-input/ExecutionHistoryModal.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+
+interface ExecutionHistoryModalProps {
+    taskId: string;
+    taskName: string;
+    onClose: () => void;
+}
+declare const ExecutionHistoryModal: React.FC<ExecutionHistoryModalProps>;
+export default ExecutionHistoryModal;

package/dist/components/renderers/task-input/TaskExecutionOutputs.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+
+interface ExecutionStatus {
+    id: string;
+    status: 'PENDING' | 'RUNNING' | 'COMPLETED' | 'FAILED' | 'CANCELED' | 'RETRY' | 'TIMEOUT';
+    outputs?: Record<string, any>;
+    [key: string]: unknown;
+}
+interface TaskExecutionOutputsProps {
+    executionStatus: ExecutionStatus | null;
+    taskId?: string;
+    compact?: boolean;
+}
+declare const TaskExecutionOutputs: React.FC<TaskExecutionOutputsProps>;
+export default TaskExecutionOutputs;

package/dist/components/renderers/task-input/TaskInputField.d.ts

@@ -0,0 +1,54 @@
+import { default as React } from 'react';
+
+interface TaskInputParam {
+    type: string;
+    required: boolean;
+    description: string;
+    default?: unknown;
+    enum?: unknown[];
+    arrayType?: string;
+    maxItems?: number;
+    maxSize?: number;
+    accept?: string;
+}
+export interface TaskInputFieldDataSourceConfig {
+    datasourceId: string;
+    valueField: string;
+    labelField: string;
+}
+interface TaskInputFieldProps {
+    fieldId: string;
+    paramName: string;
+    labelText?: string;
+    paramSchema: TaskInputParam;
+    value: unknown;
+    isUploading?: {
+        file: File;
+        progress: number;
+    };
+    arrayPreviews: Array<{
+        id: string;
+        name: string;
+        url: string;
+        type: string;
+        size: number;
+    }>;
+    compact?: boolean;
+    dataSourceConfig?: TaskInputFieldDataSourceConfig | null;
+    dataSourceOptions?: Array<{
+        value: string;
+        label: string;
+    }>;
+    requiredOverride?: boolean;
+    suppressSchemaHints?: boolean;
+    onInputChange: (fieldId: string, value: unknown) => void;
+    onFileUpload: (fieldId: string, file: File) => void;
+    onArrayFileChange: (fieldId: string, files: FileList | null, arrayType: string, maxItems?: number, maxSize?: number) => void;
+    onRemoveArrayFile: (fieldId: string, index: number) => void;
+    onFormatJSON: (fieldId: string, value: unknown) => void;
+    onCopyToClipboard: (fieldId: string, text: string) => void;
+    isFormatting: Record<string, boolean>;
+    copiedCode: Record<string, boolean>;
+}
+declare const TaskInputField: React.FC<TaskInputFieldProps>;
+export default TaskInputField;

package/dist/components/renderers/task-input/TaskInputRenderer.d.ts

@@ -0,0 +1,68 @@
+import { default as React } from 'react';
+
+interface TaskExecutionResult {
+    success: boolean;
+    data?: unknown;
+    message?: string;
+    executionId?: string;
+}
+interface TaskExecutionError {
+    message: string;
+    code?: string;
+    details?: unknown;
+}
+interface TaskInputRendererProps {
+    taskId?: string;
+    title?: string;
+    description?: string;
+    submitButtonText?: string;
+    showTitle?: boolean;
+    showDescription?: boolean;
+    showOptionalInputs?: boolean;
+    compact?: boolean;
+    embedded?: boolean;
+    embeddedFieldLayout?: 'card' | 'plain';
+    autoSubmit?: boolean;
+    className?: string;
+    onSuccessCode?: string;
+    onErrorCode?: string;
+    onSuccess?: (result: TaskExecutionResult) => void;
+    onError?: (error: TaskExecutionError) => void;
+    onParameterChange?: (key: string, value: any) => void;
+    componentId?: string;
+    parameterConfig?: {
+        parameterMapping?: Record<string, {
+            source?: string;
+            value?: string;
+            labelText?: string;
+            requiredInTaskInput?: boolean;
+            sortOrder?: number;
+        }>;
+    };
+    useMockData?: boolean;
+    mockFileData?: {
+        enabled: boolean;
+        files: Array<{
+            name: string;
+            size: number;
+            type: string;
+            content: string;
+            url: string;
+            lastModified: string;
+        }>;
+    };
+    interactiveMode?: 'professional' | 'normal';
+    submitButtonPlacement?: 'default' | 'dialogFooter';
+    isDialogExecuting?: boolean;
+    onDialogExecutingChange?: (executing: boolean) => void;
+    initialParams?: Record<string, unknown>;
+    mappingContext?: {
+        formFieldValues?: Record<string, unknown>;
+        pageParams?: Record<string, unknown>;
+    };
+}
+export interface TaskInputRendererHandle {
+    submitTask: () => Promise<void>;
+}
+declare const TaskInputRenderer: React.ForwardRefExoticComponent<TaskInputRendererProps & React.RefAttributes<TaskInputRendererHandle>>;
+export default TaskInputRenderer;

package/dist/components/renderers/task-input/index.d.ts

@@ -0,0 +1 @@
+export { default as TaskInputRenderer } from './TaskInputRenderer';

package/dist/components/renderers/task-input.js

@@ -0,0 +1,5 @@
+import { b2 as a } from "./runtime-DX1LfmqO.js";
+export {
+  a as TaskInputRenderer
+};
+//# sourceMappingURL=task-input.js.map

package/dist/components/renderers/task-input.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"task-input.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}

package/dist/components/renderers/tile-grid/TileGridRenderer.d.ts

@@ -0,0 +1,41 @@
+import { default as React } from 'react';
+import { DatabaseDataSourceConfig } from '../../types/databaseDataSource';
+import { ComponentParameterConfig } from '../../types/parameters';
+
+type Bi = string | {
+    zh?: string;
+    en?: string;
+};
+interface TileBand {
+    key?: string;
+    max?: number;
+    color?: string;
+    heat?: boolean;
+    label?: Bi;
+    tileClass?: string;
+    valueClass?: string;
+    barClass?: string;
+    heatColor?: string;
+}
+export interface TileGridRendererProps {
+    id?: string;
+    databaseDataSourceConfig?: DatabaseDataSourceConfig | null;
+    componentParameterConfig?: ComponentParameterConfig;
+    pageParams?: Record<string, unknown>;
+    rows?: Record<string, unknown>[];
+    topField?: string;
+    valueField?: string;
+    bandField?: string;
+    bands?: TileBand[];
+    cols?: number;
+    showBars?: boolean;
+    showLegend?: boolean;
+    title?: Bi;
+    bare?: boolean;
+    emptyText?: Bi;
+    titleFontSize?: number;
+    valueFontSize?: number;
+    labelFontSize?: number;
+}
+declare const TileGridRenderer: React.FC<TileGridRendererProps>;
+export default TileGridRenderer;

package/dist/components/renderers/tile-grid/index.d.ts

@@ -0,0 +1 @@
+export { default as TileGridRenderer } from './TileGridRenderer';

package/dist/components/renderers/tile-grid.js

@@ -0,0 +1,5 @@
+import { b4 as d } from "./runtime-DX1LfmqO.js";
+export {
+  d as TileGridRenderer
+};
+//# sourceMappingURL=tile-grid.js.map

package/dist/components/renderers/tile-grid.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"tile-grid.js","sources":[],"sourcesContent":[],"names":[],"mappings":";"}