@tenorlab/react-dashboard 1.6.5 → 1.6.6

package/dist/react-dashboard.d.ts

@@ -0,0 +1,719 @@
+import { CSSProperties } from 'react';
+import { default as default_2 } from 'react';
+import { ForwardRefExoticComponent } from 'react';
+import { JSX } from 'react';
+import { JSX as JSX_2 } from 'react/jsx-runtime';
+import { ReactNode } from 'react';
+import { RefAttributes } from 'react';
+import { StoreApi } from 'zustand';
+import { UseBoundStore } from 'zustand';
+
+export declare const AddIcon: typeof PlusCircleIcon;
+
+export declare function Button(props: IButtonProps): JSX_2.Element;
+
+export declare function ChevronDownIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function CircleQuestionMark({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function CrosshairIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare const DashboardGrid: ForwardRefExoticComponent<IDashboardGridProps & RefAttributes<HTMLDivElement>>;
+
+export declare const DashboardWidgetBase: (props: IDashboardWidgetProps & {
+    ref?: React.ForwardedRef<HTMLDivElement>;
+}) => React.ReactElement | null;
+
+export declare function DeleteIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare const DraggablePanel: ForwardRefExoticComponent<DraggablePanelProps & RefAttributes<HTMLDivElement>>;
+
+declare type DraggablePanelProps = {
+    testId?: string;
+    className: string;
+    style?: CSSProperties;
+    zIndex?: number;
+    onDraggingChange?: (isDragging: boolean) => void;
+    children: React.ReactNode;
+};
+
+export declare const Dropdown: default_2.FC<TProps>;
+
+/**
+ * Component to safely load and render dynamic widgets.
+ * This ensures the widget component (and its hooks) is called consistently.
+ * @param {object} props
+ * @param {string} props.widgetKey
+ * @param {(key: string) => Promise<void>} props.onRemoveClick
+ */
+export declare function DynamicWidgetLoader({ index, maxIndex, widgetKey, parentWidgetKey, targetContainerKey, childWidgetsConfig, savedProps, widgetCatalog, isEditing, extraProps, onRemoveClick, onMoveClick, selectContainer, savedPropsChanged, }: TDynamicWidgetLoaderProps): JSX_2.Element;
+
+export declare function EditIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function GridIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function HandGrabIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function HandIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare interface IButtonProps {
+    disabled?: boolean;
+    className?: string;
+    tooltip?: ITooltipProps;
+    isIconButton?: boolean;
+    buttonType?: TButtonType;
+    category?: string;
+    font?: string;
+    border?: number;
+    borderHover?: number;
+    borderColor?: string;
+    px?: number;
+    py?: number;
+    justifyCss?: TButtonJustifyCss;
+    shadow?: string;
+    shadowHover?: string;
+    addCss?: string;
+    onClick: (ev?: any) => any;
+    children: React.ReactNode;
+}
+
+export declare interface IButtonProps {
+    disabled?: boolean;
+    className?: string;
+    tooltip?: ITooltipProps;
+}
+
+/**
+ * @name IChildWidgetConfigEntry
+ * @description Interface for a child widget configuration entry
+ * @remarks Used in IDashboardConfig
+ * @see IDashboardConfig
+ */
+export declare interface IChildWidgetConfigEntry {
+    parentWidgetKey: TDashboardWidgetKey;
+    widgetKey: TDashboardWidgetKey;
+}
+
+/**
+ * @name IDashboardConfig
+ * @description Interface for the dashboard configuration
+ * @remarks Used to store the dashboard state
+ * @see IChildWidgetConfigEntry
+ * @see IDashboardSettingEntry
+ */
+export declare interface IDashboardConfig {
+    userID: number | string;
+    clientAppKey: string;
+    dashboardId: string;
+    dashboardName: string;
+    zoomScale: number;
+    responsiveGrid: boolean;
+    widgets: TDashboardWidgetKey[];
+    childWidgetsConfig: IChildWidgetConfigEntry[];
+    savedProps?: IWidgetSavedProps[];
+    cssSettings: IDashboardSettingEntry[];
+    _version?: number;
+    _stateDescription?: string;
+}
+
+/**
+ * @name IDashboardGridProps
+ * @description Dashboard grid properties interface specific to React framework.
+ * This interface extends the base dashboard grid properties interface with optional children.
+ */
+export declare interface IDashboardGridProps extends IDashboardGridPropsBase {
+    children?: ReactNode;
+}
+
+/**
+ * @name IDashboardGridPropsBase
+ * @description Base interface for dashboard grid props passed to widgets.
+ * @remarks
+ * - `zoomScale` represents a uniform zoom applied to the dashboard UI. Default
+ *   behavior in the runtime clamps this value to a minimum of `0.7` and default
+ *   is `1` when not explicitly set.
+ * - `responsiveGrid` toggles responsive layout behaviors vs fixed grid sizing.
+ */
+export declare interface IDashboardGridPropsBase {
+    isEditing: boolean;
+    zoomScale: number;
+    responsiveGrid: boolean;
+}
+
+/**
+ * @name IDashboardSettingEntry
+ * @description Interface for a dashboard setting entry
+ * @see cssSettingsCatalog in dashboard-settings.ts
+ */
+export declare interface IDashboardSettingEntry {
+    key: string;
+    name: string;
+    description: string;
+    cssProperty: string;
+    step: number;
+    defaultUnit: string;
+    minValue: number;
+    defaultValue: string;
+    value: string;
+}
+
+/**
+ * @name IDashboardStorageService
+ * @description Interface for the dashboard storage service
+ * @remarks Used to define the storage service methods
+ * @see TGetSavedDashboards
+ * @see TSaveDashboards
+ * @see IDashboardConfig
+ */
+export declare interface IDashboardStorageService {
+    getSavedDashboards: TGetSavedDashboards;
+    saveDashboards: TSaveDashboards;
+}
+
+/**
+ * @name IDashboardWidget
+ * @description A type representing a React dashboard widget element.
+ * This type is defined as a JSX.Element.
+ */
+export declare interface IDashboardWidget extends JSX.Element {
+}
+
+/**
+ * @name IDashboardWidgetProps
+ * @description Dashboard widget properties interface specific to React framework.
+ * This interface extends the base dashboard widget properties interface with additional React-specific properties.
+ * @template TExtraProps - Additional properties specific to the widget.
+ */
+export declare interface IDashboardWidgetProps<TExtraProps = any> extends IDashboardWidgetPropsBase<TExtraProps> {
+    children?: ReactNode;
+    titleNode?: ReactNode;
+    titleRightNode?: ReactNode;
+    onRemoveClick?: (widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => void;
+    onMoveClick?: (direction: -1 | 1, widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => void;
+    selectContainer?: (containerKey?: TDashboardWidgetKey) => void;
+    savedPropsChanged?: (value: IWidgetSavedProps) => any;
+}
+
+/**
+ * @name IDashboardWidgetPropsBase
+ * @description Props provided to every widget instance rendered by the dashboard.
+ * @template TExtraProps - Additional, widget-specific props supplied by the
+ * dashboard or integrator via the dynamic loader.
+ * @remarks
+ * - `index` and `maxIndex` indicate the widget's position and the current
+ *   maximum index used for ordering (zero-based indexing is typical).
+ * - `widgetKey` is the stable `TDashboardWidgetKey` identifying the widget
+ *   type; `parentWidgetKey` is set for nested/child widgets.
+ * - Boolean flags like `hideTitle`, `noShadow`, `noBorder`, `noPadding` are
+ *   layout/presentation hints; default behavior should be documented by the
+ *   concrete widget implementation.
+ * - `direction` applies to container widgets only.
+ * - `extraProps` is merged into the widget props by the `DynamicWidgetLoader`.
+ */
+export declare interface IDashboardWidgetPropsBase<TExtraProps = any> {
+    index: number;
+    maxIndex: number;
+    widgetKey: TDashboardWidgetKey;
+    parentWidgetKey?: TDashboardWidgetKey;
+    isEditing: boolean;
+    highlight?: boolean;
+    testId?: string;
+    title?: string;
+    size?: TWidgetSize;
+    borderCssClasses?: string;
+    backgroundCssClasses?: string;
+    addCssClasses?: string;
+    overrideCssClasses?: string;
+    tags?: string[];
+    hideTitle?: boolean;
+    noShadow?: boolean;
+    noBorder?: boolean;
+    noPadding?: boolean;
+    noCollapse?: boolean;
+    direction?: TWidgetDirection;
+    widgetSavedProps?: IWidgetSavedProps;
+    meta?: TWidgetMetaInfoBase;
+    extraProps?: TExtraProps;
+}
+
+/**
+ * @name IDynamicWidgetCatalogEntry
+ * @description Dynamic widget catalog entry interface specific to React framework.
+ * This interface extends the base dynamic widget catalog entry interface with React-specific element and component types.
+ * @template TFrameworkElementType - The React element type.
+ * @template TFrameworkComponentType - The React component type.
+ */
+export declare interface IDynamicWidgetCatalogEntry extends IDynamicWidgetCatalogEntryBase<TFrameworkElementType, TFrameworkComponentType> {
+}
+
+/**
+ * @name IDynamicWidgetCatalogEntryBase
+ * @description Catalog entry describing how to create or load a widget.
+ * @template TFrameworkElementType - Framework-specific element type (icon, element)
+ * @template TFrameworkComponentType - Framework-specific component type
+ * @remarks
+ * - `key` must be unique and stable across versions because it is stored in
+ *   saved dashboard configurations.
+ * - `title` is the display name for catalogs and selection UIs.
+ * - `isContainer` indicates a widget that can host children.
+ * - `isRemote` marks entries that are expected to be loaded remotely (CDN,
+ *   external script) and may require extra loading/initialization steps.
+ * - `meta` contains presentation metadata (see `TWidgetMetaInfoBase`).
+ * - `component` is a direct component reference (preferred for static/core widgets).
+ * - `loader` is an async factory used for dynamic/plugin widgets. When both
+ *   `component` and `loader` are provided, loaders are typically used for
+ *   dynamic initialization; concrete loaders/components precedence should be
+ *   defined by the integrator.
+ */
+export declare interface IDynamicWidgetCatalogEntryBase<TFrameworkElementType = any, TFrameworkComponentType = any> {
+    key: TDashboardWidgetKey;
+    title: string;
+    isContainer?: boolean;
+    isRemote?: boolean;
+    meta?: TWidgetMetaInfoBase<TFrameworkElementType>;
+    component?: TFrameworkComponentType;
+    loader?: TWidgetFactoryBase<TFrameworkComponentType>;
+}
+
+/**
+ * Compares two version strings (e.g., "19.2.0" and "19.2.3")
+ * Returns true if the widget version is compatible with the host.
+ * Logic: Host must be >= Widget version for major/minor.
+ */
+export declare const _isVersionCompatible: (hostVer: string, widgetVer: string) => boolean;
+
+export declare interface ITextFieldProps {
+    label: string;
+    size?: TSize;
+    value: string;
+    className?: string;
+    placeholder?: string;
+    onChange: (event: React.ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown?: (event: React.KeyboardEvent<HTMLInputElement>) => void;
+}
+
+export declare interface ITooltipProps {
+    placement: string;
+    title: string;
+}
+
+export declare interface ITooltipProps {
+    placement: string;
+    title: string;
+}
+
+declare interface IWidgetSavedProps {
+    parentWidgetKey?: TDashboardWidgetKey;
+    widgetKey: TDashboardWidgetKey;
+    isCollapsed?: boolean;
+}
+
+export declare const ListItem: ForwardRefExoticComponent<TStackProps & {
+innerClass?: string;
+} & RefAttributes<HTMLDivElement>>;
+
+export declare const ListItemLeftChild: ForwardRefExoticComponent<TListItemChildProps & RefAttributes<HTMLDivElement>>;
+
+export declare const ListItemMiddleChild: ForwardRefExoticComponent<TListItemChildProps & RefAttributes<HTMLDivElement>>;
+
+export declare const ListItemRightChild: ForwardRefExoticComponent<TListItemChildProps & RefAttributes<HTMLDivElement>>;
+
+export declare function MinusCircleIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function MonitorIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function MonitorSmartphoneIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function MoveLeftIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function MoveRightIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function PlusCircleIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function RedoIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function RenameIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function SettingsIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare const showToast: (options: any) => void;
+
+export declare function Stack(props: TStackProps): JSX_2.Element;
+
+export declare function SvgBaseWrapper({ children, className, style, }: {
+    children: React.ReactNode;
+    className?: string;
+    style?: React.CSSProperties;
+}): JSX_2.Element;
+
+export declare function TabletSmartphoneIcon({ className, style }: TIconProps): JSX_2.Element;
+
+/**
+ * @name TAddWidgetResponse
+ * @description Type for the response of the addWidget mutation
+ * @property {boolean} success - Indicates if the widget was added successfully
+ * @property {string} [message] - Optional message providing additional information
+ * @property {IDashboardConfig} updatedDashboardConfig - The updated dashboard configuration after adding the widget
+ * @property {IDashboardConfig[]} allUpdatedDashboardConfigs - All updated dashboard configurations
+ */
+declare type TAddWidgetResponse = {
+    success: boolean;
+    message?: string;
+    updatedDashboardConfig: IDashboardConfig;
+    allUpdatedDashboardConfigs: IDashboardConfig[];
+};
+
+export declare function TargetIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare type TButtonJustifyCss = 'justify-start' | 'justify-center' | 'justify-end';
+
+export declare type TButtonType = 'normal' | 'ghost';
+
+declare type TDashboardSlice = {
+    isLoading: boolean;
+    isEditing: boolean;
+    allDashboardConfigs: IDashboardConfig[];
+    currentDashboardConfig: IDashboardConfig;
+    targetContainerKey?: TDashboardWidgetKey | undefined;
+    getNextContainerKey: (containerWidgetKey: TDashboardWidgetKey) => TDashboardWidgetKey;
+    getCurrentDashboardConfig: () => IDashboardConfig;
+    getCurrentDashboardId: () => string;
+    getIsResponsive: () => boolean;
+    getTargetContainerKey: () => TDashboardWidgetKey | undefined;
+    setIsLoading: (value: boolean) => boolean;
+    setIsEditing: (value: boolean) => boolean;
+    setTargetContainerKey: (value: TDashboardWidgetKey | undefined) => TDashboardWidgetKey | undefined;
+    setAllDashboardConfigs: (value: IDashboardConfig[]) => IDashboardConfig[];
+    setCurrentDashboardConfig: (value: IDashboardConfig) => IDashboardConfig[];
+    addDashboardConfig: (value: IDashboardConfig) => IDashboardConfig[];
+    deleteDashboardConfigById: (value: string) => IDashboardConfig[];
+    selectDashboardById: (dashboardId: string) => IDashboardConfig | undefined;
+    addWidget: (params: {
+        widgetKey: TDashboardWidgetKey;
+        parentWidgetKey?: TDashboardWidgetKey;
+        noDuplicatedWidgets?: boolean;
+    }) => TAddWidgetResponse;
+    removeWidget: (widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => TRemoveWidgetResponse;
+    moveWidget: (direction: -1 | 1, widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => TRemoveWidgetResponse;
+};
+
+export declare type TDashboardUndoService = ReturnType<typeof useDashboardUndoService>;
+
+/**
+ * @name TDashboardUndoStatus
+ * @description Type for the dashboard undo/redo status
+ * @remarks Used in dashboard undo/redo functionality
+ */
+export declare type TDashboardUndoStatus = {
+    isUndoDisabled: boolean;
+    isRedoDisabled: boolean;
+    _currentIndex?: number;
+    _historyLength?: number;
+};
+
+/**
+ * @name TDashboardWidgetCatalog
+ * @description Dashboard widget catalog type specific to React framework.
+ * This type extends the base dashboard widget catalog type with React-specific element and component types.
+ * @template TFrameworkElementType - The React element type.
+ * @template TFrameworkComponentType - The React component type.
+ */
+export declare type TDashboardWidgetCatalog = TDashboardWidgetCatalogBase<TFrameworkElementType, TFrameworkComponentType>;
+
+/**
+ * @name TDashboardWidgetCatalogBase
+ * @description Map of available widgets used by the dashboard at runtime.
+ * @template TFrameworkElementType - Framework-specific element type
+ * @template TFrameworkComponentType - Framework-specific component type
+ * @remarks Keys are `TDashboardWidgetKey` and values are catalog entries. The
+ * map is typically treated as a read-only registry; replace the map to update
+ * the available widget set rather than mutating entries in-place.
+ */
+export declare type TDashboardWidgetCatalogBase<TFrameworkElementType = any, TFrameworkComponentType = any> = Map<TDashboardWidgetKey, IDynamicWidgetCatalogEntryBase<TFrameworkElementType, TFrameworkComponentType>>;
+
+/**
+ * @name TDashboardWidgetKey
+ * @description Type for the unique key identifying a dashboard widget.
+ * @remarks
+ * This is a simple alias for `string` to allow flexibility in widget keys.
+ * Recommended formats: stable short strings (e.g. `myApp.ChartWidget`),
+ * namespaced identifiers or UUIDs. Consumers should avoid empty strings.
+ */
+export declare type TDashboardWidgetKey = string;
+
+declare type TDynamicWidgetLoaderProps<TExtraProps = any> = {
+    index: number;
+    maxIndex: number;
+    widgetKey: TDashboardWidgetKey;
+    parentWidgetKey?: TDashboardWidgetKey;
+    targetContainerKey?: TDashboardWidgetKey;
+    childWidgetsConfig?: IChildWidgetConfigEntry[];
+    savedProps?: IWidgetSavedProps[];
+    widgetCatalog: TDashboardWidgetCatalog;
+    isEditing: boolean;
+    extraProps?: TExtraProps;
+    onRemoveClick?: (widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => void;
+    onMoveClick?: (direction: -1 | 1, widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => void;
+    selectContainer?: (containerKey: TDashboardWidgetKey) => void;
+    savedPropsChanged: (value: IWidgetSavedProps) => any;
+};
+
+/**
+ * A reusable, styled TextField component built with Tailwind CSS.
+ */
+export declare const TextField: default_2.FC<ITextFieldProps>;
+
+/**
+ * @name TFrameworkComponentType
+ * @description A type representing a React component type.
+ */
+declare type TFrameworkComponentType = React.ComponentType<any>;
+
+/**
+ * @name TFrameworkElementType
+ * @description A type representing a React element type.
+ */
+declare type TFrameworkElementType = React.ElementType;
+
+/**
+ * @name TGetSavedDashboards
+ * @description Function type to get saved dashboards for a user
+ * @remarks Used in IDashboardStorageService
+ * @see IDashboardConfig
+ * @see TDashboardWidgetCatalogBase
+ * @return Promise<IDashboardConfig[]>
+ */
+declare type TGetSavedDashboards = (userID: number | string, clientAppKey: string, widgetCatalog: TDashboardWidgetCatalogBase, defaultDashboardConfig: IDashboardConfig) => Promise<IDashboardConfig[]>;
+
+declare type TIconProps = {
+    className?: string;
+    style?: React.CSSProperties;
+};
+
+export declare function TimerResetIcon({ className, style }: TIconProps): JSX_2.Element;
+
+declare type TListItemChildProps = {
+    testId?: string;
+    className?: string;
+    children?: ReactNode;
+};
+
+/**
+ * @name TManifestEntry
+ * @description Entry describing a remote widget manifest or resource.
+ * @remarks
+ * - `url` should point to the resource or manifest (absolute URLs recommended).
+ * - `meta` contains widget metadata (see `TWidgetMetaInfoBase`) describing the
+ *   remotely loaded widget.
+ */
+export declare type TManifestEntry = {
+    url: string;
+    meta: TWidgetMetaInfoBase;
+};
+
+declare interface TProps {
+    testid?: string;
+    label?: string;
+    hideLabel?: boolean;
+    showChevron?: boolean;
+    hide?: boolean;
+    enabled: boolean;
+    isMenuOpen: boolean;
+    toggleOpen: (open: boolean) => void;
+    icon?: ReactNode;
+    children?: ReactNode;
+}
+
+declare type TProps_2 = {
+    children: React.ReactNode;
+    addCssClasses?: string;
+};
+
+declare type TRemoveWidgetResponse = TAddWidgetResponse;
+
+/**
+ * @name TSaveDashboards
+ * @description Function type to save dashboards for a user
+ * @remarks Used in IDashboardStorageService
+ * @see IDashboardConfig
+ * @see TDashboardWidgetCatalogBase
+ * @return Promise<boolean>
+ */
+declare type TSaveDashboards = (userID: number | string, clientAppKey: string, dashboardConfigs: IDashboardConfig[], widgetCatalog: TDashboardWidgetCatalogBase) => Promise<boolean>;
+
+declare type TSize = 'small' | 'medium';
+
+export declare type TStackProps = {
+    testId?: string;
+    classNames?: string;
+    direction?: 'row' | 'column';
+    style?: CSSProperties;
+    children: React.ReactNode;
+};
+
+/**
+ * @name TUndoHistoryEntry
+ * @description Type for an undo history entry
+ * @remarks Used in dashboard undo/redo functionality
+ * @see IDashboardConfig
+ */
+export declare type TUndoHistoryEntry = {
+    undoIndex: number;
+    config: IDashboardConfig;
+};
+
+/**
+ * @name TWidgetCategory
+ * @description Type for widget categories used for grouping and UI filters.
+ * @remarks
+ * Typical usage: categorizing widgets in a palette, grouping by behavior
+ * (for instance `Container` widgets may host child widgets).
+ */
+export declare type TWidgetCategory = 'Widget' | 'Chart' | 'Container';
+
+/**
+ * @name TWidgetDirection
+ * @description Direction for layout flow inside container widgets.
+ * @remarks Only meaningful for container-type widgets that arrange children in
+ * either `row` or `column` flow.
+ */
+export declare type TWidgetDirection = 'row' | 'column';
+
+export declare type TWidgetErrorExtraProps = {
+    versionMismatch: boolean;
+    requiredVer: string;
+    hostVer: string;
+    errorMessage: string;
+    externalDependencies: string[];
+};
+
+/**
+ * @name TWidgetFactory
+ * @description A type representing a widget factory function specific to React framework.
+ * This type extends the base widget factory type with React-specific component type.
+ * @template TFrameworkComponentType - The React component type.
+ */
+export declare type TWidgetFactory = TWidgetFactoryBase<TFrameworkComponentType>;
+
+/**
+ * @name TWidgetFactoryBase
+ * @description Async factory used to lazily load a framework component for a widget.
+ * @template TFrameworkComponent - Framework-specific component type (e.g., React component)
+ * @returns Promise resolving to an object with a `default` export containing the component.
+ * @remarks Implementations should throw on unrecoverable load errors so callers
+ * can handle fallbacks; returning a stub is also acceptable when documented.
+ */
+export declare type TWidgetFactoryBase<TFrameworkComponent = any> = () => Promise<{
+    default: TFrameworkComponent;
+}>;
+
+/**
+ * @name TWidgetMetaInfo
+ * @description Widget meta information type specific to React framework.
+ * This type extends the base widget meta information type with React-specific element type.
+ */
+export declare type TWidgetMetaInfo = TWidgetMetaInfoBase<TFrameworkElementType | undefined>;
+
+/**
+ * @name TWidgetMetaInfoBase
+ * @description Base metadata for a widget used by catalogs and tooling.
+ * @template TFrameworkElementType - Framework-specific element type (e.g. React element, Vue component)
+ * @remarks
+ * Fields:
+ * - `name` (required): Human readable widget name.
+ * - `description` (required): Short description shown in tooltips or catalog lists.
+ * - `categories` (required): One or more `TWidgetCategory` values used for grouping.
+ * - `noDuplicatedWidgets` (optional): When true, dashboard UI should prevent
+ *   adding multiple instances of this widget.
+ * - `icon` (optional): Framework-specific icon element or component. May be
+ *   `undefined` when not provided.
+ * - `externalDependencies` (required): Array of package identifiers or CDN
+ *   references (e.g. `react@19.2.3`, `https://cdn.example.com/widget.js`). Use
+ *   semantic versions or absolute URLs as appropriate.
+ *
+ * Example:
+ * {
+ *   name: 'Simple Chart',
+ *   description: 'Displays a time series',
+ *   categories: ['Chart'],
+ *   noDuplicatedWidgets: false,
+ *   icon: undefined,
+ *   externalDependencies: ['d3@7.0.0']
+ * }
+ */
+export declare type TWidgetMetaInfoBase<TFrameworkElementType = any> = {
+    name: string;
+    description: string;
+    categories: TWidgetCategory[];
+    noDuplicatedWidgets?: boolean;
+    icon?: TFrameworkElementType | string | undefined;
+    externalDependencies: string[];
+    tags?: string[];
+    noCollapse?: boolean;
+};
+
+export declare type TWidgetsCatalogFlyoutProps = {
+    targetContainerKey?: TDashboardWidgetKey;
+    widgetsCatalog: TDashboardWidgetCatalog;
+    currentDashboardConfig: IDashboardConfig;
+    undoStatus: TDashboardUndoStatus;
+    zIndex?: number;
+    addWidget: (widgetKey: TDashboardWidgetKey, parentWidgetKey?: TDashboardWidgetKey) => any;
+    addContainer: (widgetKey: TDashboardWidgetKey) => any;
+    onSettingItemsUpdated: (items: IDashboardSettingEntry[]) => any;
+    onResetToDefaultDashboardClick: () => any;
+    onUndoOrRedo: (operation: 'Undo' | 'Redo') => any;
+    onDoneClick: () => any;
+};
+
+/**
+ * @name TWidgetSize
+ * @description Size hint for widgets that can affect layout or styling.
+ * @remarks 'default' represents the standard size; 'large' and 'xlarge' are
+ * larger variants where the dashboard may allocate more grid cells.
+ */
+export declare type TWidgetSize = 'default' | 'large' | 'xlarge';
+
+export declare function UndoIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare const useDashboardStore: UseBoundStore<Omit<StoreApi<TDashboardSlice>, "subscribe"> & {
+subscribe: {
+(listener: (selectedState: TDashboardSlice, previousSelectedState: TDashboardSlice) => void): () => void;
+<U>(selector: (state: TDashboardSlice) => U, listener: (selectedState: U, previousSelectedState: U) => void, options?: {
+equalityFn?: ((a: U, b: U) => boolean) | undefined;
+fireImmediately?: boolean;
+} | undefined): () => void;
+};
+}>;
+
+export declare const useDashboardUndoService: () => {
+    initializeHistoryForDashboard: (initialConfig: IDashboardConfig) => void;
+    resetAllHistory: () => void;
+    addUndoEntry: (newConfig: IDashboardConfig) => void;
+    removeUndoHistoryForDashboard: (dashboardId: string) => void;
+    undo: (currentDashboardId: string) => void;
+    redo: (currentDashboardId: string) => void;
+    getUndoStatus: (currentDashboardId: string) => TDashboardUndoStatus;
+    undoHistory: Record<string, TUndoHistoryEntry[]>;
+    historyIndex: Record<string, number>;
+};
+
+export declare function WidgetContainerColumn(props: IDashboardWidgetProps): IDashboardWidget;
+
+export declare function WidgetContainerLarge(props: IDashboardWidgetProps): IDashboardWidget;
+
+export declare function WidgetContainerRow(props: IDashboardWidgetProps): IDashboardWidget;
+
+export declare function WidgetsCatalogFlyout(props: TWidgetsCatalogFlyoutProps): JSX_2.Element;
+
+export declare function WrapperColumnContent({ children, addCssClasses }: TProps_2): JSX_2.Element;
+
+export declare function WrapperColumnContentListItem({ children, addCssClasses }: TProps_2): JSX_2.Element;
+
+export declare function XCircleIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function ZoomInIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export declare function ZoomOutIcon({ className, style }: TIconProps): JSX_2.Element;
+
+export { }