@genispace/geniapp 0.2.0 → 0.4.0

package/dist/components/internal/workbench/components/skeleton/TileGridSkeleton.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+
+export interface TileGridSkeletonProps {
+    cols?: number;
+    count?: number;
+    showTitle?: boolean;
+    showLegend?: boolean;
+    className?: string;
+}
+export declare function TileGridSkeleton({ cols, count, showTitle, showLegend, className, }: TileGridSkeletonProps): React.JSX.Element;
+export default TileGridSkeleton;

package/dist/components/internal/workbench/components/skeleton/WorkbenchSkeletonTokens.d.ts

@@ -0,0 +1 @@
+export { Skeleton, skeletonBarWidth, skeletonItemCount } from '../../../shared-ui/index.ts';

package/dist/components/internal/workbench/components/skeleton/index.d.ts

@@ -0,0 +1,4 @@
+export { Skeleton, skeletonBarWidth, skeletonItemCount, ListSkeleton, ChartAreaSkeleton, ChartEmptyState, TableEmptyState, EmptyStateBadge, ComponentSkeletonShell, TablePageSkeleton, StatsRowSkeleton, type ListSkeletonProps, type ListSkeletonTemplate, type ChartAreaSkeletonProps, type ChartEmptyStateProps, type TableEmptyStateProps, type EmptyStateBadgeProps, type ChartSkeletonType, type ComponentSkeletonShellProps, } from '../../../shared-ui/index.ts';
+export { HeroCardSkeleton, type HeroCardSkeletonProps } from './HeroCardSkeleton';
+export { TileGridSkeleton, type TileGridSkeletonProps } from './TileGridSkeleton';
+export { ComponentSkeleton, type ComponentSkeletonProps } from './ComponentSkeleton';

package/dist/components/internal/workbench/components/ui/ActionFormDialog.d.ts

@@ -0,0 +1,19 @@
+import { default as React } from 'react';
+import { TableDataType, TableAction, TableColumnType } from '../../types/renderers';
+import { ParameterRecord } from '../../types/parameters';
+
+type StructuredFieldType = 'JSON' | 'ARRAY';
+export declare function serializeStructuredFormValue(value: unknown, fieldType?: string): unknown;
+export declare function parseStructuredFormValue(value: unknown, fieldType?: StructuredFieldType): unknown;
+interface ActionFormDialogProps {
+    isOpen: boolean;
+    action: TableAction | null;
+    record: TableDataType | null;
+    pageParams?: ParameterRecord;
+    onSubmit: (formData: ParameterRecord) => Promise<void>;
+    onClose: () => void;
+    loading?: boolean;
+    tableColumns?: TableColumnType[];
+}
+export declare const ActionFormDialog: React.FC<ActionFormDialogProps>;
+export default ActionFormDialog;

package/dist/components/internal/workbench/components/ui/ConfirmDialog.d.ts

@@ -0,0 +1,17 @@
+import { default as React } from 'react';
+
+interface ConfirmDialogProps {
+    isOpen: boolean;
+    onClose: () => void;
+    onConfirm?: () => void;
+    title?: string;
+    message?: string;
+    details?: string[];
+    buttonType?: 'default' | 'destructive' | 'outline' | 'secondary' | 'approve' | 'reject' | 'success' | 'warning' | 'info';
+    buttonLabel?: string;
+    actionType?: 'delete' | 'insert' | 'update' | 'custom' | 'error-general' | 'error-url' | 'error-file' | 'error-field';
+    loading?: boolean;
+    mode?: 'confirm' | 'alert';
+}
+export declare const ConfirmDialog: React.FC<ConfirmDialogProps>;
+export {};

package/dist/components/internal/workbench/components/ui/FormFieldRenderer.d.ts

@@ -0,0 +1,51 @@
+import { default as React } from 'react';
+import { SwitchConfig, TableColumnType } from '../../types/renderers';
+
+export interface FormField {
+    name: string;
+    label: string;
+    type: 'input' | 'textarea' | 'select' | 'date' | 'number' | 'switch' | 'password' | 'color' | 'file';
+    required?: boolean;
+    hidden?: boolean;
+    readonly?: boolean;
+    placeholder?: string;
+    defaultValue?: any;
+    options?: Array<{
+        text: string;
+        value: string;
+    }>;
+    dateTimeMode?: 'date' | 'datetime';
+    switchConfig?: SwitchConfig;
+    dictionarySelectColumn?: Pick<TableColumnType, 'dataIndex' | 'dictionaryDataSource'>;
+    selectDatasource?: {
+        datasourceId?: string;
+        version?: number;
+        valueField?: string;
+        labelField?: string;
+    };
+    validation?: {
+        min?: number;
+        max?: number;
+        minRef?: {
+            source: 'field' | 'record';
+            key: string;
+        };
+        maxRef?: {
+            source: 'field' | 'record';
+            key: string;
+        };
+        minLength?: number;
+        maxLength?: number;
+        pattern?: string;
+        message?: string;
+    };
+    help?: string;
+}
+interface FormFieldRendererProps {
+    field: FormField;
+    value: any;
+    onChange: (value: any) => void;
+    error?: string;
+}
+export declare const FormFieldRenderer: React.FC<FormFieldRendererProps>;
+export default FormFieldRenderer;

package/dist/components/internal/workbench/components/ui/IconSelector.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+
+interface IconSelectorProps {
+    value?: string;
+    onChange: (value: string) => void;
+    placeholder?: string;
+    className?: string;
+}
+export declare const IconSelector: React.FC<IconSelectorProps>;
+export {};

package/dist/components/internal/workbench/components/ui/RecordDetailDialog.d.ts

@@ -0,0 +1,15 @@
+import { default as React } from 'react';
+import { TableDataType, TableRendererProps } from '../../types/renderers';
+
+type RecordInteraction = NonNullable<TableRendererProps['recordInteraction']>;
+interface RecordDetailDialogProps {
+    open: boolean;
+    record: TableDataType | null;
+    config: RecordInteraction;
+    onClose: () => void;
+    onEdit?: () => void;
+}
+type StructuredLabelResolver = (key: string) => string;
+export declare const formatRecordDetailValue: (value: unknown, format: NonNullable<RecordInteraction["fields"]>[number]["format"], resolveLabel?: StructuredLabelResolver) => React.ReactNode;
+export declare const RecordDetailDialog: React.FC<RecordDetailDialogProps>;
+export {};

package/dist/components/internal/workbench/components/ui/StructuredValueField.d.ts

@@ -0,0 +1,16 @@
+import { default as React } from 'react';
+
+type JsonObject = Record<string, unknown>;
+interface StructuredValueFieldProps {
+    id: string;
+    label: string;
+    value: unknown;
+    onChange: (value: string) => void;
+    error?: string;
+    readonly?: boolean;
+    required?: boolean;
+    itemTemplate?: JsonObject;
+    fieldLabels?: Record<string, string>;
+}
+export declare const StructuredValueField: React.FC<StructuredValueFieldProps>;
+export {};

package/dist/components/internal/workbench/components/ui/date-picker.d.ts

@@ -0,0 +1,7 @@
+import * as React from "react";
+export interface DatePickerProps {
+    selected?: Date;
+    onChange?: (date: Date | null) => void;
+    placeholderText?: string;
+}
+export declare function DatePicker({ selected, onChange, placeholderText }: DatePickerProps): React.JSX.Element;

package/dist/components/internal/workbench/components/ui/date-range-picker.d.ts

@@ -0,0 +1,11 @@
+import * as React from "react";
+export interface DateRange {
+    from?: Date;
+    to?: Date;
+}
+export interface DateRangePickerProps {
+    dateRange?: DateRange;
+    onChange?: (dateRange: DateRange) => void;
+    placeholderText?: string;
+}
+export declare function DateRangePicker({ dateRange, onChange, placeholderText }: DateRangePickerProps): React.JSX.Element;

package/dist/components/internal/workbench/components/ui/dialog-safe-select.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const DialogSafeSelect: React.FC<SelectPrimitive.SelectProps>;
+declare const DialogSafeSelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const DialogSafeSelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogSafeSelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DialogSafeSelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { DialogSafeSelect, DialogSafeSelectGroup, DialogSafeSelectValue, DialogSafeSelectTrigger, DialogSafeSelectContent, DialogSafeSelectLabel, DialogSafeSelectItem, DialogSafeSelectSeparator, DialogSafeSelectScrollUpButton, DialogSafeSelectScrollDownButton, };

package/dist/components/internal/workbench/components/ui/dialog-tag-input.d.ts

@@ -0,0 +1,18 @@
+import * as React from "react";
+export interface DialogTagInputProps {
+    value: string[];
+    onChange: (value: string[]) => void;
+    placeholder?: string;
+    label?: string;
+    dialogTitle?: string;
+    dialogDescription?: string;
+    confirmText?: string;
+    cancelText?: string;
+    disabled?: boolean;
+    className?: string;
+    style?: React.CSSProperties;
+    minWidth?: string;
+    maxTags?: number;
+    allowDuplicates?: boolean;
+}
+export declare const DialogTagInput: React.ForwardRefExoticComponent<DialogTagInputProps & React.RefAttributes<HTMLInputElement>>;

package/dist/components/internal/workbench/components/ui/dialog.d.ts

@@ -0,0 +1,22 @@
+import * as React from "react";
+import * as DialogPrimitive from "@radix-ui/react-dialog";
+declare const Dialog: React.FC<DialogPrimitive.DialogProps>;
+declare const DialogTrigger: React.ForwardRefExoticComponent<DialogPrimitive.DialogTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogPortal: React.FC<DialogPrimitive.DialogPortalProps>;
+declare const DialogClose: React.ForwardRefExoticComponent<DialogPrimitive.DialogCloseProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DialogOverlay: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogOverlayProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+interface DialogContentProps extends React.ComponentPropsWithoutRef<typeof DialogPrimitive.Content> {
+    nested?: boolean;
+}
+declare const DialogContent: React.ForwardRefExoticComponent<DialogContentProps & React.RefAttributes<HTMLDivElement>>;
+declare const DialogHeader: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogFooter: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLDivElement>): React.JSX.Element;
+    displayName: string;
+};
+declare const DialogTitle: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogTitleProps & React.RefAttributes<HTMLHeadingElement>, "ref"> & React.RefAttributes<HTMLHeadingElement>>;
+declare const DialogDescription: React.ForwardRefExoticComponent<Omit<DialogPrimitive.DialogDescriptionProps & React.RefAttributes<HTMLParagraphElement>, "ref"> & React.RefAttributes<HTMLParagraphElement>>;
+export { Dialog, DialogPortal, DialogOverlay, DialogTrigger, DialogClose, DialogContent, DialogHeader, DialogFooter, DialogTitle, DialogDescription, };

package/dist/components/internal/workbench/components/ui/dropdown-menu.d.ts

@@ -0,0 +1,27 @@
+import * as React from "react";
+import * as DropdownMenuPrimitive from "@radix-ui/react-dropdown-menu";
+declare const DropdownMenu: React.FC<DropdownMenuPrimitive.DropdownMenuProps>;
+declare const DropdownMenuTrigger: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuTriggerProps & React.RefAttributes<HTMLButtonElement>>;
+declare const DropdownMenuGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuPortal: React.FC<DropdownMenuPrimitive.DropdownMenuPortalProps>;
+declare const DropdownMenuSub: React.FC<DropdownMenuPrimitive.DropdownMenuSubProps>;
+declare const DropdownMenuRadioGroup: React.ForwardRefExoticComponent<DropdownMenuPrimitive.DropdownMenuRadioGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubTrigger: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubTriggerProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSubContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSubContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuContent: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuCheckboxItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuCheckboxItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuRadioItem: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuRadioItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuLabel: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & {
+    inset?: boolean;
+} & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuSeparator: React.ForwardRefExoticComponent<Omit<DropdownMenuPrimitive.DropdownMenuSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const DropdownMenuShortcut: {
+    ({ className, ...props }: React.HTMLAttributes<HTMLSpanElement>): React.JSX.Element;
+    displayName: string;
+};
+export { DropdownMenu, DropdownMenuTrigger, DropdownMenuContent, DropdownMenuItem, DropdownMenuCheckboxItem, DropdownMenuRadioItem, DropdownMenuLabel, DropdownMenuSeparator, DropdownMenuShortcut, DropdownMenuGroup, DropdownMenuPortal, DropdownMenuSub, DropdownMenuSubContent, DropdownMenuSubTrigger, DropdownMenuRadioGroup, };

package/dist/components/internal/workbench/components/ui/pagination.d.ts

@@ -0,0 +1,28 @@
+import { ButtonProps } from '../../../shared-ui/index.ts';
+import * as React from "react";
+declare const Pagination: {
+    ({ className, ...props }: React.ComponentProps<"nav">): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const PaginationItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+type PaginationLinkProps = {
+    isActive?: boolean;
+} & Pick<ButtonProps, "size"> & React.ComponentProps<"a">;
+declare const PaginationLink: {
+    ({ className, isActive, size, ...props }: PaginationLinkProps): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationPrevious: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationNext: {
+    ({ className, ...props }: React.ComponentProps<typeof PaginationLink>): React.JSX.Element;
+    displayName: string;
+};
+declare const PaginationEllipsis: {
+    ({ className, ...props }: React.ComponentProps<"span">): React.JSX.Element;
+    displayName: string;
+};
+export { Pagination, PaginationContent, PaginationLink, PaginationItem, PaginationPrevious, PaginationNext, PaginationEllipsis, };

package/dist/components/internal/workbench/components/ui/select.d.ts

@@ -0,0 +1,13 @@
+import * as React from "react";
+import * as SelectPrimitive from "@radix-ui/react-select";
+declare const Select: React.FC<SelectPrimitive.SelectProps>;
+declare const SelectGroup: React.ForwardRefExoticComponent<SelectPrimitive.SelectGroupProps & React.RefAttributes<HTMLDivElement>>;
+declare const SelectValue: React.ForwardRefExoticComponent<SelectPrimitive.SelectValueProps & React.RefAttributes<HTMLSpanElement>>;
+declare const SelectTrigger: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectTriggerProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SelectScrollUpButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollUpButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectScrollDownButton: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectScrollDownButtonProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectContent: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectContentProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectLabel: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectLabelProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectItem: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectItemProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SelectSeparator: React.ForwardRefExoticComponent<Omit<SelectPrimitive.SelectSeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+export { Select, SelectGroup, SelectValue, SelectTrigger, SelectContent, SelectLabel, SelectItem, SelectSeparator, SelectScrollUpButton, SelectScrollDownButton, };

package/dist/components/internal/workbench/components/ui/sidebar-rail.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+
+interface SidebarRailProps {
+    collapsed: boolean;
+    onToggle: () => void;
+    show?: boolean;
+}
+export declare const SidebarRail: React.FC<SidebarRailProps>;
+export {};

package/dist/components/internal/workbench/components/ui/sidebar.d.ts

@@ -0,0 +1,65 @@
+import { VariantProps } from 'class-variance-authority';
+import { TooltipContent } from '../../../shared-ui/index.ts';
+import * as React from "react";
+type SidebarContextProps = {
+    state: "expanded" | "collapsed";
+    open: boolean;
+    setOpen: (open: boolean) => void;
+    openMobile: boolean;
+    setOpenMobile: (open: boolean) => void;
+    isMobile: boolean;
+    toggleSidebar: () => void;
+};
+declare function useSidebar(): SidebarContextProps;
+declare const SidebarProvider: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    defaultOpen?: boolean;
+    open?: boolean;
+    onOpenChange?: (open: boolean) => void;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const Sidebar: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    side?: "left" | "right";
+    variant?: "sidebar" | "floating" | "inset";
+    collapsible?: "offcanvas" | "icon" | "none";
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarTrigger: React.ForwardRefExoticComponent<Omit<import('../../../shared-ui/index.ts').ButtonProps & React.RefAttributes<HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarRail: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.ButtonHTMLAttributes<HTMLButtonElement>, HTMLButtonElement>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarInset: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLElement>, HTMLElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarInput: React.ForwardRefExoticComponent<Omit<Omit<React.DetailedHTMLProps<React.InputHTMLAttributes<HTMLInputElement>, HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>, "ref"> & React.RefAttributes<HTMLInputElement>>;
+declare const SidebarHeader: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarFooter: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarSeparator: React.ForwardRefExoticComponent<Omit<import('../../../shared-ui/index.ts').SeparatorProps & React.RefAttributes<HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroup: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupLabel: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarGroupAction: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarGroupContent: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenu: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const SidebarMenuButton: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    isActive?: boolean;
+    tooltip?: string | React.ComponentProps<typeof TooltipContent>;
+} & VariantProps<(props?: {
+    variant?: "default" | "outline";
+    size?: "default" | "sm" | "lg";
+} & import('class-variance-authority/types').ClassProp) => string>, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuAction: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLButtonElement> & React.ButtonHTMLAttributes<HTMLButtonElement> & {
+    asChild?: boolean;
+    showOnHover?: boolean;
+}, "ref"> & React.RefAttributes<HTMLButtonElement>>;
+declare const SidebarMenuBadge: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLDivElement>, HTMLDivElement>, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSkeleton: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLDivElement> & React.HTMLAttributes<HTMLDivElement> & {
+    showIcon?: boolean;
+}, "ref"> & React.RefAttributes<HTMLDivElement>>;
+declare const SidebarMenuSub: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.HTMLAttributes<HTMLUListElement>, HTMLUListElement>, "ref"> & React.RefAttributes<HTMLUListElement>>;
+declare const SidebarMenuSubItem: React.ForwardRefExoticComponent<Omit<React.DetailedHTMLProps<React.LiHTMLAttributes<HTMLLIElement>, HTMLLIElement>, "ref"> & React.RefAttributes<HTMLLIElement>>;
+declare const SidebarMenuSubButton: React.ForwardRefExoticComponent<Omit<React.ClassAttributes<HTMLAnchorElement> & React.AnchorHTMLAttributes<HTMLAnchorElement> & {
+    asChild?: boolean;
+    size?: "sm" | "md";
+    isActive?: boolean;
+}, "ref"> & React.RefAttributes<HTMLAnchorElement>>;
+export { Sidebar, SidebarContent, SidebarFooter, SidebarGroup, SidebarGroupAction, SidebarGroupContent, SidebarGroupLabel, SidebarHeader, SidebarInput, SidebarInset, SidebarMenu, SidebarMenuAction, SidebarMenuBadge, SidebarMenuButton, SidebarMenuItem, SidebarMenuSkeleton, SidebarMenuSub, SidebarMenuSubButton, SidebarMenuSubItem, SidebarProvider, SidebarRail, SidebarSeparator, SidebarTrigger, useSidebar, };

package/dist/components/internal/workbench/components/ui/table.d.ts

@@ -0,0 +1,10 @@
+import * as React from "react";
+declare const Table: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableElement> & React.RefAttributes<HTMLTableElement>>;
+declare const TableHeader: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableBody: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableFooter: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableSectionElement> & React.RefAttributes<HTMLTableSectionElement>>;
+declare const TableRow: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableRowElement> & React.RefAttributes<HTMLTableRowElement>>;
+declare const TableHead: React.ForwardRefExoticComponent<React.ThHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCell: React.ForwardRefExoticComponent<React.TdHTMLAttributes<HTMLTableCellElement> & React.RefAttributes<HTMLTableCellElement>>;
+declare const TableCaption: React.ForwardRefExoticComponent<React.HTMLAttributes<HTMLTableCaptionElement> & React.RefAttributes<HTMLTableCaptionElement>>;
+export { Table, TableHeader, TableBody, TableFooter, TableHead, TableRow, TableCell, TableCaption, };

package/dist/components/internal/workbench/components/ui/tag-input.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { Input } from '../../../shared-ui/index.ts';
+
+export interface TagInputProps {
+    value: string[];
+    onChange: (tags: string[]) => void;
+    placeholder?: string;
+    disabled?: boolean;
+    maxTags?: number;
+    allowDuplicates?: boolean;
+    validateTag?: (tag: string) => boolean | string;
+    separator?: string | RegExp;
+    className?: string;
+    inputClassName?: string;
+    tagsContainerClassName?: string;
+    badgeVariant?: 'default' | 'secondary' | 'destructive' | 'outline';
+    onBlurBehavior?: 'add' | 'ignore';
+    onTagAdd?: (tag: string) => void;
+    onTagRemove?: (tag: string, index: number) => void;
+    inputProps?: React.ComponentProps<typeof Input>;
+}
+export declare const TagInput: React.ForwardRefExoticComponent<TagInputProps & React.RefAttributes<HTMLInputElement>>;
+export default TagInput;

package/dist/components/internal/workbench/config/communicationIcons.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+
+export type IconName = keyof typeof COMMUNICATION_ICONS;
+export type IconComponent = React.ComponentType<{
+    className?: string;
+    size?: number | string;
+}>;
+export interface IconCategory {
+    name: string;
+    label: string;
+    description: string;
+    icons: IconName[];
+}
+export declare const COMMUNICATION_ICONS: Record<string, IconComponent>;
+export declare const ICON_CATEGORIES: IconCategory[];
+export declare const getIcon: (iconName: string, defaultIcon?: IconName) => IconComponent;
+export declare const getIconsByCategory: (categoryName: string) => IconName[];
+export declare const getAllIconNames: () => IconName[];
+export declare const isValidIconName: (iconName: string) => iconName is IconName;
+export declare const getRecommendedIconsForTriggerCategory: (category: string) => IconName[];
+export declare const createIconComponent: (iconName: string, className?: string) => React.ReactElement;
+export declare const LEGACY_ICON_MAP: Record<string, IconName>;
+export declare const convertLegacyIconName: (legacyName: string) => IconName;

package/dist/components/internal/workbench/config/componentTriggers.d.ts

@@ -0,0 +1,70 @@
+import { ComponentTypeDefinition, ParameterDefinition, ComponentTrigger } from '../types/communication';
+
+export declare const COMMON_PARAMETERS: Record<string, ParameterDefinition>;
+export declare const COMMUNICATION_ONLY_PARAMETERS: readonly ["lastTaskResult", "tableRefreshTrigger", "chartRefreshTrigger", "listRefreshTrigger", "treeRefreshTrigger", "lastFormResult", "dataChangeNotification", "formValidationState", "formDataChanged", "taskStatusChanged", "currentTaskInfo", "selectedTreeNode"];
+export declare const isCommunicationOnlyParameter: (parameterKey: string) => boolean;
+export declare const COMPONENT_TRIGGERS: Record<string, ComponentTypeDefinition>;
+export declare const getComponentTriggers: (componentType: string) => ComponentTypeDefinition | null;
+export declare const getAllAvailableParameters: () => ParameterDefinition[];
+export declare const getParametersByCategory: (category: string) => ParameterDefinition[];
+export declare const getCommonParameters: () => ParameterDefinition[];
+export declare const getTriggersByComponent: (componentType: string) => ComponentTrigger[];
+export declare const getParameterDefinition: (parameterKey: string) => ParameterDefinition | null;
+export declare const getComponentTypes: () => ComponentTypeDefinition[];
+export declare const getComponentsByCategory: (category: string) => ComponentTypeDefinition[];
+/**
+ * Base key for the "global action succeeded" trigger. Concrete instances
+ * append a dot-separated escaped actionId (e.g. `onGlobalActionSuccess.approve`).
+ * The bare base key is preserved as a fallback for callers that want to
+ * subscribe once to "any global action success" without per-button config.
+ */
+export declare const ON_GLOBAL_ACTION_SUCCESS_BASE = "onGlobalActionSuccess";
+/**
+ * Replace characters that would break the dot-separated trigger key with
+ * `_`. Currently only `.` matters because we use dots as the separator,
+ * but this function is the single source of truth — if the separator ever
+ * changes, only this function needs updating.
+ */
+export declare function escapeActionIdForTrigger(actionId: string): string;
+/**
+ * Build the trigger key for a given global action. Use the same function on
+ * both the renderer side (when emitting) and the editor side (when deriving
+ * the trigger list) so they always agree.
+ */
+export declare function globalActionSuccessTriggerKey(actionId: string): string;
+/**
+ * Build the per-action trigger list from a Table's `actions` array.
+ * Only `position: 'global'` actions are included. Returns an empty array
+ * when no actions are provided so the caller can safely concatenate.
+ */
+export declare function getGlobalActionSuccessTriggers(actions: ReadonlyArray<{
+    id?: string;
+    position?: string;
+    label?: string;
+}> | undefined): ComponentTrigger[];
+/**
+ * Base key for the "row action succeeded" trigger. Concrete instances
+ * append a dot-separated escaped actionId (e.g. `onRowActionSuccess.edit`).
+ */
+export declare const ON_ROW_ACTION_SUCCESS_BASE = "onRowActionSuccess";
+/**
+ * Build the trigger key for a given row action.
+ */
+export declare function rowActionSuccessTriggerKey(actionId: string): string;
+/**
+ * Build the per-action trigger list from a Table's `actions` array.
+ * Only non-global (`position !== 'global'`) actions are included.
+ */
+export declare function getRowActionSuccessTriggers(actions: ReadonlyArray<{
+    id?: string;
+    position?: string;
+    label?: string;
+}> | undefined): ComponentTrigger[];
+/**
+ * Merge global and row per-button success triggers for the communication panel.
+ */
+export declare function getPerButtonActionSuccessTriggers(actions: ReadonlyArray<{
+    id?: string;
+    position?: string;
+    label?: string;
+}> | undefined): ComponentTrigger[];

package/dist/components/internal/workbench/constants/tableActionButtonStyle.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Table / EditableTable action button styles: shared by property panel options, i18n fallbacks,
+ * help route, and TableRenderer behavior. (Not help-only; help content reuses the same variant list.)
+ */
+export declare const TABLE_ACTION_BUTTON_STYLE_HELP_PATH: "/help/table-action-button-style";
+export declare const TABLE_ACTION_BUTTON_STYLE_VARIANTS: readonly ["default", "destructive", "outline", "secondary", "approve", "reject", "success", "warning", "info"];
+export type TableActionButtonStyleVariant = (typeof TABLE_ACTION_BUTTON_STYLE_VARIANTS)[number];
+/** English fallbacks for useTranslation('editor') keys table_property_editor.button_style_*; matches t(key, default) second arg */
+export declare const TABLE_ACTION_BUTTON_STYLE_LABEL_FALLBACK: Record<TableActionButtonStyleVariant, string>;
+/**
+ * Action types that open `ActionFormDialog` when `TableRenderer` has `inputMode === 'form'`.
+ * The property panel should align when showing direct vs form confirm and form options (incl. DB insert/delete, etc.).
+ */
+export declare const TABLE_ACTION_TYPES_WITH_FORM_MODE: readonly ["updateDataset", "insertDataset", "updateDatabase", "insertDatabase", "deleteDatabase", "transactionDatabase"];
+export declare function tableActionSupportsFormMode(type: string): boolean;

package/dist/components/internal/workbench/contexts/PageFullscreenContext.d.ts

@@ -0,0 +1,4 @@
+import { default as React } from 'react';
+
+export declare const PageFullscreenProvider: React.Provider<boolean>;
+export declare function usePageFullscreen(): boolean;

package/dist/components/internal/workbench/contexts/ParameterContext.d.ts

@@ -0,0 +1,18 @@
+import { default as React } from 'react';
+import { ParameterContextValue, ParameterRecord, ParameterParseConfig, ParameterValue } from '../types/parameters';
+
+declare const ParameterContext: React.Context<ParameterContextValue>;
+export { ParameterContext };
+interface ParameterProviderProps {
+    children: React.ReactNode;
+    tabId: string;
+    pageId: string;
+    initialParams?: ParameterRecord;
+}
+export declare const parseUrlParameters: (config?: ParameterParseConfig) => ParameterRecord;
+export declare const ParameterProvider: React.FC<ParameterProviderProps>;
+export declare const useParameterContext: () => ParameterContextValue;
+export declare const usePageParameters: () => ParameterRecord;
+export declare const useParameter: (key: string) => ParameterValue;
+export declare const useParameters: (keys: string[]) => Record<string, any>;
+export declare const clearAllTabParameters: () => void;

package/dist/components/internal/workbench/contexts/TabActivityContext.d.ts

@@ -0,0 +1,2 @@
+export declare const TabActivityProvider: import('react').Provider<boolean>;
+export declare function useTabActivity(): boolean;

package/dist/components/internal/workbench/contexts/ViewportContext.d.ts

@@ -0,0 +1,19 @@
+import { default as React, ReactNode } from 'react';
+import { ViewportMode, ViewportSource } from '../mobile/utils/getMobileViewportState';
+
+export type { ViewportMode };
+interface ViewportContextValue {
+    mode: ViewportMode;
+    isMobile: boolean;
+    /** True when on desktop browser with a manual mobile preview override. */
+    canReturnToDesktop: boolean;
+    viewportSource: ViewportSource;
+    isWeCom: boolean;
+    forceMobile: () => void;
+    forceDesktop: () => void;
+    reset: () => void;
+}
+export declare function ViewportProvider({ children }: {
+    children: ReactNode;
+}): React.JSX.Element;
+export declare function useViewport(): ViewportContextValue;

package/dist/components/internal/workbench/contexts/WorkbenchConfigLocaleContext.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { PageConfig } from '../types/components';
+import { WorkbenchConfigWithLocales, WorkbenchLocaleMetadata } from '../utils/workbenchConfigLocale';
+import { LocaleLabelMap } from '../utils/workbenchDisplayLocale';
+
+type WorkbenchConfigLocaleContextValue = {
+    language: string;
+    metadata: WorkbenchLocaleMetadata | undefined;
+    labelMap: LocaleLabelMap | undefined;
+    localizeText: (text: string | null | undefined) => string;
+    resolveBilingualText: (text: unknown) => string;
+    localizeRows: <T extends Record<string, unknown>>(rows: T[] | null | undefined) => T[];
+    localizeWorkbenchConfig: (config: WorkbenchConfigWithLocales | null | undefined) => WorkbenchConfigWithLocales | null | undefined;
+    localizeAppConfig: <T extends Record<string, unknown>>(appConfig: T | undefined) => T | undefined;
+    localizePageConfig: <T extends Record<string, unknown>>(pageId: string, pageConfig: T | undefined) => T | undefined;
+};
+export declare const WorkbenchConfigLocaleProvider: React.FC<{
+    metadata: WorkbenchLocaleMetadata | undefined;
+    children: React.ReactNode;
+}>;
+export declare const useWorkbenchConfigLocale: () => WorkbenchConfigLocaleContextValue;
+export declare const useLocalizedPageConfig: (pageId: string, pageConfig: PageConfig | undefined) => PageConfig | undefined;
+export {};