@genispace/geniapp 0.3.0 → 0.5.0

package/dist/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/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/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/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/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/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/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/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/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/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/ui/pagination.d.ts

@@ -0,0 +1,28 @@
+import { ButtonProps } from '../shared/platform-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/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/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/ui/sidebar.d.ts

@@ -0,0 +1,65 @@
+import { VariantProps } from 'class-variance-authority';
+import { TooltipContent } from '../shared/platform-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/platform-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/platform-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/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/ui/tag-input.d.ts

@@ -0,0 +1,23 @@
+import { default as React } from 'react';
+import { Input } from '../shared/platform-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/utils/actionFormValidation.d.ts

@@ -0,0 +1,34 @@
+import { FormField } from '../ui/FormFieldRenderer';
+import { TableDataType } from '../types/renderers';
+
+/** Reference another field or a record value as the min/max bound */
+export interface ActionFieldValidationRef {
+    source: 'field' | 'record';
+    key: string;
+}
+export interface ActionFieldValidation {
+    min?: number;
+    max?: number;
+    minRef?: ActionFieldValidationRef;
+    maxRef?: ActionFieldValidationRef;
+    minLength?: number;
+    maxLength?: number;
+    pattern?: string;
+    message?: string;
+}
+/** Range rule from transactionDatabase.validation, keyed by field name */
+export interface ActionDatabaseValidationRule {
+    type?: 'required' | 'minLength' | 'maxLength' | 'pattern' | 'range' | 'custom';
+    min?: number;
+    max?: number;
+    minRef?: ActionFieldValidationRef;
+    maxRef?: ActionFieldValidationRef;
+    value?: unknown;
+    message?: string;
+}
+/** Merge updateFields[].validation with transactionDatabase.validation */
+export declare function resolveActionFieldValidation(fieldName: string, fieldConfig: {
+    validation?: ActionFieldValidation;
+} | undefined, databaseValidation: Record<string, ActionDatabaseValidationRule> | undefined): FormField['validation'] | undefined;
+export declare function validateActionFormField(field: FormField, value: unknown, formData: Record<string, unknown>, record: TableDataType | null, t: (key: string, defaultValue: string, opts?: Record<string, unknown>) => string): string | null;
+export declare function validateActionForm(formFields: FormField[], formData: Record<string, unknown>, record: TableDataType | null, t: (key: string, defaultValue: string, opts?: Record<string, unknown>) => string): Record<string, string>;

package/dist/components/utils/autoIdUtils.d.ts

@@ -0,0 +1,2 @@
+export declare function generateAutoId(): number;
+export declare function processInsertDataWithAutoId(formData: Record<string, any>, rowKey: string, useAutoId?: boolean): Record<string, any>;

package/dist/components/utils/chartGradientStops.d.ts

@@ -0,0 +1,14 @@
+export type GradientStop = {
+    offset: string;
+    color: string;
+};
+export declare function parseCssColorToRgb(color: string): {
+    r: number;
+    g: number;
+    b: number;
+} | null;
+export declare function colorToRgba(color: string, alpha: number): string;
+export declare function lightenColor(color: string, ratio: number): string;
+export declare function darkenColor(color: string, ratio: number): string;
+export declare function getTopToBottomGradientStops(color: string): GradientStop[];
+export declare function getLineAreaGradientStops(color: string): GradientStop[];

package/dist/components/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/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/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/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/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/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;