mui-toolpad-extended-tuni 2.0.0 → 3.0.0

package/dist/src/common/components/ui/Panel/Expandable/hooks/useCollapseHandler.d.ts

@@ -0,0 +1,2 @@
+import { PanelRef } from '../../types';
+export declare const useCollapseHandler: (isExpanded: boolean, expandedPanelId: string | null, id: string, panelRef: PanelRef, setExtendedStyle: (style: React.CSSProperties) => void, setExtendedContainerStyle: (style: React.CSSProperties) => void, setIsExpanded: (expanded: boolean) => void) => void;

package/dist/src/common/components/ui/Panel/Expandable/hooks/useExpandable.d.ts

@@ -0,0 +1,17 @@
+/** @format */
+interface UseExpandableOptions {
+    initialExpanded?: boolean;
+    onExpand?: () => void;
+    onCollapse?: () => void;
+}
+interface UseExpandableReturn {
+    isExpanded: boolean;
+    toggle: () => void;
+    expand: () => void;
+    collapse: () => void;
+}
+/**
+ * Hook for managing expandable panel state
+ */
+export declare const useExpandable: ({ initialExpanded, onExpand, onCollapse, }?: UseExpandableOptions) => UseExpandableReturn;
+export {};

package/dist/src/common/components/ui/Panel/Expandable/hooks/useExpansionAnimation.d.ts

@@ -0,0 +1,5 @@
+import { PanelRef } from '../../types';
+export declare const useExpansionAnimation: (readyForExpansion: boolean, panelRef: PanelRef, parentRef: PanelRef, setExtendedStyle: (style: React.CSSProperties) => void, setExtendedContainerStyle: (style: React.CSSProperties) => void, setIsExpanded: (expanded: boolean) => void, setReadyForExpansion: (ready: boolean) => void) => {
+    animateExpansion: boolean;
+    setAnimateExpansion: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+};

package/dist/src/common/components/ui/Panel/Expandable/hooks/useInitialSetup.d.ts

@@ -0,0 +1,6 @@
+import { Position, PanelRef } from '../../types';
+export declare const useInitialSetup: (expandedPanelId: string | null, id: string, panelRef: PanelRef, setExtendedStyle: (style: React.CSSProperties) => void) => {
+    readyForExpansion: boolean;
+    setReadyForExpansion: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    initialPosition: Position;
+};

package/dist/src/common/components/ui/Panel/Expandable/hooks/useResizeHandler.d.ts

@@ -0,0 +1 @@
+export declare const useResizeHandler: (isExpanded: boolean) => void;

package/dist/src/common/components/ui/Panel/Expandable/store/useExpandablePanelStore.d.ts

@@ -0,0 +1,7 @@
+/** @format */
+interface ExpandablePanelState {
+    expandedPanelId: string | null;
+    setExpandedPanelId: (id: string | null) => void;
+}
+export declare const useExpandablePanelStore: import('zustand/traditional').UseBoundStoreWithEqualityFn<import('zustand').StoreApi<ExpandablePanelState>>;
+export {};

package/dist/src/common/components/ui/Panel/Main/Context/PanelContextProvider.d.ts

@@ -0,0 +1,50 @@
+import { default as React } from 'react';
+import { PanelRef } from '../../types';
+export interface PanelDimensions {
+    width: number;
+    height: number;
+}
+interface PanelContextType {
+    id: string;
+    panelRef: PanelRef;
+    panelContentRef: PanelRef;
+    defaultWidth: number;
+    defaultHeight: number;
+    minWidth: number;
+    maxWidth: number;
+    minHeight: number;
+    maxHeight: number;
+    expandable?: boolean;
+    resizable?: boolean;
+    scrollable?: boolean;
+    extendedStyle: React.CSSProperties;
+    setExtendedStyle: (style: React.CSSProperties) => void;
+    tools: React.ReactNode[];
+    setTools: (tools: React.ReactNode[]) => void;
+    addTool: (tool: React.ReactNode) => void;
+    removeTool: (tool: React.ReactNode) => void;
+    dimensions: PanelDimensions;
+    setDimensions: (dimensions: PanelDimensions) => void;
+    handleDimensionsChange: (newDimensions: PanelDimensions, isTemporary?: boolean) => void;
+    dimensionsWereTemporary: boolean;
+    extendedContainerStyle: React.CSSProperties;
+    setExtendedContainerStyle: (style: React.CSSProperties) => void;
+}
+export declare const PanelContext: React.Context<PanelContextType>;
+export interface PanelProps {
+    children: React.ReactNode;
+    id: string;
+    additionaltools?: React.ReactNode[];
+    minHeight?: number;
+    maxHeight?: number;
+    minWidth?: number;
+    maxWidth?: number;
+    defaultHeight?: number;
+    defaultWidth?: number;
+    expandable?: boolean;
+    resizable?: boolean;
+    scrollable?: boolean;
+}
+export declare const PanelProvider: React.FC<PanelProps>;
+export declare const usePanelContext: () => PanelContextType;
+export {};

package/dist/src/common/components/ui/Panel/Main/Panel.d.ts

@@ -0,0 +1,3 @@
+import { PanelProps } from './Context/PanelContextProvider';
+export declare const Panel: (props: PanelProps) => import("react/jsx-runtime").JSX.Element;
+export default Panel;

package/dist/src/common/components/ui/Panel/Main/hooks/useDimensionManagement.d.ts

@@ -0,0 +1,13 @@
+import { PanelDimensions } from '../Context/PanelContextProvider';
+interface UseDimensionManagementProps {
+    id: string;
+    dimensions: PanelDimensions;
+    handleDimensionsChange: handleDimensionsChangeType;
+}
+export type handleDimensionsChangeType = (dimensions: PanelDimensions, isTemporary: boolean) => void;
+export declare const useDimensionManagement: ({ id, dimensions, handleDimensionsChange, }: UseDimensionManagementProps) => {
+    isUserResizingRef: import('react').RefObject<boolean>;
+    userChosenDimensionsRef: import('react').RefObject<any>;
+    wrappedHandleDimensionsChange: (newDim: PanelDimensions) => void;
+};
+export {};

package/dist/src/common/components/ui/Panel/Main/hooks/usePersistentDimensions.d.ts

@@ -0,0 +1,19 @@
+/** @format */
+/**
+ * loadDimensions:
+ * Attempts to retrieve stored panel dimensions by ID from localStorage,
+ * falling back to provided defaultDimensions if none found.
+ */
+export declare function loadDimensions(id: string, defaultDimensions: {
+    width: number;
+    height: number;
+}): any;
+/**
+ * saveDimensions:
+ * Persists the given dimensions in localStorage under a unique ID key,
+ * allowing the panel to restore its last settings at load time.
+ */
+export declare function saveDimensions(id: string, dimensions: {
+    width: number;
+    height: number;
+}): void;

package/dist/src/common/components/ui/Panel/Main/tools/BlurOverlay.d.ts

@@ -0,0 +1,6 @@
+import { default as React } from 'react';
+interface BlurOverlayProps {
+    children: React.ReactNode;
+}
+declare const BlurOverlay: ({ children }: BlurOverlayProps) => import("react/jsx-runtime").JSX.Element;
+export default BlurOverlay;

package/dist/src/common/components/ui/Panel/Main/tools/ToolsContainer.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+interface ToolsContainerProps {
+    children: React.ReactNode;
+}
+export declare const ToolsContainer: ({ children }: ToolsContainerProps) => import("react/jsx-runtime").JSX.Element;
+interface ToolsContainerWrapperProps {
+    children: React.ReactNode;
+    position?: "top-right" | "bottom-right";
+}
+export declare const ToolsContainerWrapper: ({ children, position, }: ToolsContainerWrapperProps) => import("react/jsx-runtime").JSX.Element;
+export default ToolsContainer;

package/dist/src/common/components/ui/Panel/Movable/DraggableItem.d.ts

@@ -0,0 +1,6 @@
+/** @format */
+declare function DraggableItem({ id, children, }: {
+    id: string;
+    children: React.ReactNode;
+}): import("react/jsx-runtime").JSX.Element;
+export default DraggableItem;

package/dist/src/common/components/ui/Panel/Movable/MovablePanel.d.ts

@@ -0,0 +1,9 @@
+import { default as React } from 'react';
+interface MovablePanelProps {
+    id: string;
+    children: React.ReactNode[];
+    tools?: React.ReactNode;
+    gap?: number;
+}
+declare const Panels: (props: MovablePanelProps) => import("react/jsx-runtime").JSX.Element;
+export default Panels;

package/dist/src/common/components/ui/Panel/Movable/MoveToggler.d.ts

@@ -0,0 +1,3 @@
+/** @format */
+declare const MoveToggler: () => import("react/jsx-runtime").JSX.Element;
+export default MoveToggler;

package/dist/src/common/components/ui/Panel/Movable/context/MovableContextProvider.d.ts

@@ -0,0 +1,10 @@
+import { ReactNode } from 'react';
+import { PanelRef } from '../../types';
+interface MovableContextType {
+    parentRef: PanelRef;
+}
+export declare const MovableContextProvider: ({ children, }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useMovableContext: () => MovableContextType;
+export {};

package/dist/src/common/components/ui/Panel/Movable/hooks/usePersistentOrder.d.ts

@@ -0,0 +1,3 @@
+/** @format */
+export declare function loadPanelOrder(id: string, defaultOrder: number[]): number[];
+export declare function savePanelOrder(id: string, order: number[]): void;

package/dist/src/common/components/ui/Panel/Resizable/Context/ResizableContextProvider.d.ts

@@ -0,0 +1,27 @@
+import { ReactNode, Dispatch, SetStateAction, RefObject } from 'react';
+interface leap {
+    x: number;
+    y: number;
+}
+interface DragState {
+    vertical: boolean;
+    horizontal: boolean;
+}
+interface DragStartType {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}
+interface ResizableContextType {
+    leap: leap;
+    isDragging: DragState;
+    dragStart: RefObject<DragStartType>;
+    setIsDragging: Dispatch<SetStateAction<DragState>>;
+}
+interface ResizableContextProviderProps {
+    children: ReactNode;
+}
+export declare const ResizableContextProvider: ({ children, }: ResizableContextProviderProps) => import("react/jsx-runtime").JSX.Element;
+export declare const useResizableContext: () => ResizableContextType;
+export {};

package/dist/src/common/components/ui/Panel/Resizable/Hooks/useResizeHandlers.d.ts

@@ -0,0 +1,26 @@
+/** @format */
+/**
+ * snapToGrid:
+ * Utility to snap a given numeric value to a specified grid size.
+ */
+export declare function snapToGrid(value: number, snapSize: number): number;
+/**
+ * startDragging:
+ * Creates a handler that prepares for resizing by capturing mouse/touch location
+ * and storing initial dimensions.
+ */
+export declare function startDragging(direction: "vertical" | "horizontal" | "corner", resizeMode: boolean, dimensions: {
+    width: number;
+    height: number;
+}, setIsDragging: (d: {
+    vertical: boolean;
+    horizontal: boolean;
+}) => void, dragStart: React.MutableRefObject<{
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}>, leap: {
+    x: number;
+    y: number;
+}): (e: React.MouseEvent | React.TouchEvent) => void;

package/dist/src/common/components/ui/Panel/Resizable/Hooks/useResponsiveResize.d.ts

@@ -0,0 +1,14 @@
+import { PanelRef } from '../../types';
+import { PanelDimensions } from '../../Main/Context/PanelContextProvider';
+interface UseResponsiveResizeProps {
+    panelRef: PanelRef;
+    panelContentRef: PanelRef;
+    dimensions: PanelDimensions;
+    minWidth: number;
+    minHeight: number;
+    isUserResizingRef: React.MutableRefObject<boolean>;
+    userChosenDimensionsRef: React.MutableRefObject<PanelDimensions>;
+    wrappedHandleDimensionsChange: (newDimensions: PanelDimensions) => void;
+}
+export declare const useResponsiveResize: (props: UseResponsiveResizeProps) => void;
+export {};

package/dist/src/common/components/ui/Panel/Resizable/Resizable.d.ts

@@ -0,0 +1,3 @@
+/** @format */
+declare const Resizable: () => import("react/jsx-runtime").JSX.Element;
+export default Resizable;

package/dist/src/common/components/ui/Panel/Resizable/ResizeHandlers.d.ts

@@ -0,0 +1,7 @@
+import { default as React } from 'react';
+interface ResizeHandlersProps {
+    handleMouseDown: (direction: "vertical" | "horizontal" | "corner") => (e: React.MouseEvent | React.TouchEvent) => void;
+    handleTouchStart: (direction: "vertical" | "horizontal" | "corner") => (e: React.MouseEvent | React.TouchEvent) => void;
+}
+declare const ResizeHandlers: ({ handleMouseDown, handleTouchStart, }: ResizeHandlersProps) => import("react/jsx-runtime").JSX.Element;
+export default ResizeHandlers;

package/dist/src/common/components/ui/Panel/Resizable/ResizeIndicator.d.ts

@@ -0,0 +1,9 @@
+/** @format */
+interface ResizeIndicatorProps {
+    dimensions: {
+        width: number;
+        height: number;
+    };
+}
+declare const ResizeIndicator: ({ dimensions }: ResizeIndicatorProps) => import("react/jsx-runtime").JSX.Element;
+export default ResizeIndicator;

package/dist/src/common/components/ui/Panel/Scrollable/InternalScrolling.d.ts

@@ -0,0 +1,11 @@
+/** @format */
+type InternalScrollingProps = {
+    children?: React.ReactNode;
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    isExpanded?: boolean;
+};
+declare const InternalScrolling: ({ children, dimensions, }: InternalScrollingProps) => import("react/jsx-runtime").JSX.Element;
+export default InternalScrolling;

package/dist/src/common/components/ui/Panel/Scrollable/PaginationDots.d.ts

@@ -0,0 +1,13 @@
+/** @format */
+interface PaginationDotsProps {
+    total: number;
+    current: number;
+    onDotClick?: (index: number) => void;
+    vertical?: boolean;
+    onArrowClick?: (direction: "start" | "end") => void;
+    showArrows?: boolean;
+    disableStart?: boolean;
+    disableEnd?: boolean;
+}
+declare const PaginationDots: ({ total, current, onDotClick, vertical, onArrowClick, disableStart, disableEnd, }: PaginationDotsProps) => import("react/jsx-runtime").JSX.Element | null;
+export default PaginationDots;

package/dist/src/common/components/ui/Panel/Scrollable/Scrollable.d.ts

@@ -0,0 +1,5 @@
+interface ScrollableProps {
+    children: React.ReactNode;
+}
+declare const Scrollable: ({ children }: ScrollableProps) => import("react/jsx-runtime").JSX.Element;
+export default Scrollable;

package/dist/src/common/components/ui/Panel/Scrollable/context/ScrollerContextProvider.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+export interface ItemCounts {
+    horizontal: number;
+    vertical: number;
+}
+interface ScrollerContextType {
+    itemCounts: ItemCounts;
+    setItemCounts: (counts: ItemCounts) => void;
+}
+export declare const ScrollContext: import('react').Context<ScrollerContextType>;
+export declare const ScrollerProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useScrollContext: () => ScrollerContextType;
+export {};

package/dist/src/common/components/ui/Panel/Scrollable/hooks/useScrollControls.d.ts

@@ -0,0 +1,28 @@
+interface ScrollControlsOptions {
+    direction: "horizontal" | "vertical";
+    itemSize: number;
+    itemsPerPage?: number;
+    itemCount?: number;
+}
+export declare const useScrollControls: ({ direction: scrollAxis, itemSize, itemsPerPage, itemCount, }: ScrollControlsOptions) => {
+    containerRef: import('react').RefObject<HTMLDivElement | null>;
+    showStartButton: boolean;
+    showEndButton: boolean;
+    isDragging: boolean;
+    hasDragged: boolean;
+    setHasDragged: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    scroll: (scrollDirection: "start" | "end") => void;
+    handleMouseDown: (e: React.MouseEvent) => void;
+    handleMouseMove: (e: React.MouseEvent) => void;
+    handleMouseUp: (e: React.MouseEvent) => void;
+    currentPage: number;
+    totalPages: number;
+    scrollToPage: (page: number) => void;
+    disableStartButton: boolean;
+    disableEndButton: boolean;
+    handleTouchStart: (e: React.TouchEvent) => void;
+    handleTouchMove: (e: React.TouchEvent) => void;
+    handleTouchEnd: () => void;
+    canScroll: boolean;
+};
+export {};

package/dist/src/common/components/ui/Panel/TBR/PanelContent.d.ts

@@ -0,0 +1,24 @@
+/** @format */
+interface PanelContentProps {
+    children: React.ReactNode | ((dimensions: {
+        width: number;
+        height: number;
+    }) => React.ReactNode);
+    dimensions: {
+        width: number;
+        height: number;
+    };
+    isDragging: {
+        vertical: boolean;
+        horizontal: boolean;
+    };
+    isExpanded: boolean;
+    expandable?: boolean;
+    tools?: React.ReactNode;
+    resizeMode?: boolean;
+    handleMouseDown: (direction: "vertical" | "horizontal" | "corner") => (e: React.MouseEvent | React.TouchEvent) => void;
+    handleTouchStart: (direction: "vertical" | "horizontal" | "corner") => (e: React.MouseEvent | React.TouchEvent) => void;
+    toggleExpand: () => void;
+}
+declare const PanelContent: ({ children, dimensions, isDragging, isExpanded, expandable, tools, resizeMode, handleMouseDown, toggleExpand, }: PanelContentProps) => import("react/jsx-runtime").JSX.Element;
+export default PanelContent;

package/dist/src/common/components/ui/Panel/TBR/ResizablePanel.d.ts

@@ -0,0 +1,3 @@
+import { PanelProps } from '../Main/Context/PanelContextProvider';
+declare const ResizablePanel: (props: PanelProps) => import("react/jsx-runtime").JSX.Element;
+export default ResizablePanel;

package/dist/src/common/components/ui/Panel/TBR/ResizeHandlers.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface ResizeHandlersProps {
+    isResizing: boolean;
+    onResizeStart?: (direction: string) => void;
+}
+/**
+ * Resize handles for panel resizing
+ */
+declare const ResizeHandlers: React.FC<ResizeHandlersProps>;
+export default ResizeHandlers;

package/dist/src/common/components/ui/Panel/TBR/ResizeIndicator.d.ts

@@ -0,0 +1,10 @@
+import { default as React } from 'react';
+interface ResizeIndicatorProps {
+    isResizing: boolean;
+    direction?: string;
+}
+/**
+ * Visual indicator shown when a panel is being resized
+ */
+declare const ResizeIndicator: React.FC<ResizeIndicatorProps>;
+export default ResizeIndicator;

package/dist/src/common/components/ui/Panel/TBR/useResizablePanel.d.ts

@@ -0,0 +1,32 @@
+import { PanelDimensions } from '../Main/Context/PanelContextProvider';
+import { handleDimensionsChangeType } from '../Main/hooks/useDimensionManagement';
+interface UseResizablePanelOptions {
+    id: string;
+    defaultWidth: number;
+    defaultHeight: number;
+    minWidth: number;
+    maxWidth: number;
+    minHeight: number;
+    maxHeight: number;
+    snapDimensions: PanelDimensions;
+    onResize?: (dimensions: PanelDimensions) => void;
+}
+export declare function useResizablePanel({ id, defaultWidth, defaultHeight, minWidth, maxWidth, minHeight, maxHeight, snapDimensions, }: UseResizablePanelOptions): {
+    dimensions: any;
+    isDragging: {
+        vertical: boolean;
+        horizontal: boolean;
+    };
+    setIsDragging: import('react').Dispatch<import('react').SetStateAction<{
+        vertical: boolean;
+        horizontal: boolean;
+    }>>;
+    dragStart: import('react').RefObject<{
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    }>;
+    handleDimensionsChange: handleDimensionsChangeType;
+};
+export {};

package/dist/src/common/components/ui/Panel/types.d.ts

@@ -0,0 +1,9 @@
+export interface Position {
+    top: number;
+    left: number;
+}
+export interface Dimensions {
+    width: number;
+    height: number;
+}
+export type PanelRef = React.RefObject<HTMLDivElement | null>;

package/dist/src/common/components/ui/Scroller/PaginationDots.d.ts

@@ -0,0 +1,13 @@
+/** @format */
+interface PaginationDotsProps {
+    total: number;
+    current: number;
+    onDotClick?: (index: number) => void;
+    vertical?: boolean;
+    onArrowClick?: (direction: "start" | "end") => void;
+    showArrows?: boolean;
+    disableStart?: boolean;
+    disableEnd?: boolean;
+}
+declare const PaginationDots: ({ total, current, onDotClick, vertical, onArrowClick, disableStart, disableEnd, }: PaginationDotsProps) => import("react/jsx-runtime").JSX.Element | null;
+export default PaginationDots;

package/dist/src/common/components/ui/Scroller/Scroller.d.ts

@@ -0,0 +1,14 @@
+import { priority } from './types';
+import { ReactNode } from 'react';
+interface ScrollerProps {
+    direction: "vertical" | "horizontal";
+    children: ReactNode;
+    itemSize: number;
+    containerSize?: string | number;
+    hideScrollbar?: boolean;
+    snapScroll?: boolean;
+    title?: string;
+    priority?: priority;
+}
+declare const Scroller: ({ direction, children, itemSize, containerSize, hideScrollbar, snapScroll, title, priority, }: ScrollerProps) => import("react/jsx-runtime").JSX.Element;
+export default Scroller;

package/dist/src/common/components/ui/Scroller/context/ScrollerContextProvider.d.ts

@@ -0,0 +1,15 @@
+import { ReactNode } from 'react';
+export interface ItemCounts {
+    horizontal: number;
+    vertical: number;
+}
+interface ScrollerContextType {
+    itemCounts: ItemCounts;
+    setItemCounts: (counts: ItemCounts) => void;
+}
+export declare const ScrollContext: import('react').Context<ScrollerContextType>;
+export declare const ScrollerProvider: ({ children }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useScrollContext: () => ScrollerContextType;
+export {};

package/dist/src/common/components/ui/Scroller/hooks/useScrollControls.d.ts

@@ -0,0 +1,28 @@
+interface ScrollControlsOptions {
+    direction: "horizontal" | "vertical";
+    itemSize: number;
+    itemsPerPage?: number;
+    itemCount?: number;
+}
+export declare const useScrollControls: ({ direction: scrollAxis, itemSize, itemsPerPage, itemCount, }: ScrollControlsOptions) => {
+    containerRef: import('react').RefObject<HTMLDivElement | null>;
+    showStartButton: boolean;
+    showEndButton: boolean;
+    isDragging: boolean;
+    hasDragged: boolean;
+    setHasDragged: import('react').Dispatch<import('react').SetStateAction<boolean>>;
+    scroll: (scrollDirection: "start" | "end") => void;
+    handleMouseDown: (e: React.MouseEvent) => void;
+    handleMouseMove: (e: React.MouseEvent) => void;
+    handleMouseUp: (e: React.MouseEvent) => void;
+    currentPage: number;
+    totalPages: number;
+    scrollToPage: (page: number) => void;
+    disableStartButton: boolean;
+    disableEndButton: boolean;
+    handleTouchStart: (e: React.TouchEvent) => void;
+    handleTouchMove: (e: React.TouchEvent) => void;
+    handleTouchEnd: () => void;
+    canScroll: boolean;
+};
+export {};

package/dist/src/common/components/ui/Scroller/types.d.ts

@@ -0,0 +1 @@
+export type priority = "high" | "low" | "normal";

package/dist/src/common/components/ui/SpeedDialButton/SpeedDialButton.d.ts

@@ -0,0 +1,20 @@
+import { default as React } from 'react';
+import { default as SpeedDialAction } from '@mui/material/SpeedDialAction';
+interface SpeedDialAction {
+    icon: React.ReactNode;
+    name: string;
+    value: string;
+}
+interface SpeedDialButtonProps {
+    actions: SpeedDialAction[];
+    value: string;
+    direction?: "up" | "down" | "left" | "right";
+    onChange: (value: string) => void;
+    icons: {
+        [key: string]: React.ReactNode;
+    };
+    openIcon?: React.ReactNode;
+    size?: number;
+}
+export declare const SpeedDialButton: ({ actions, value, direction, onChange, icons, openIcon, size, }: SpeedDialButtonProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/common/components/ui/ThemeToggle/ThemeToggle.d.ts

@@ -0,0 +1,3 @@
+/** @format */
+export declare const ThemeToggle: () => import("react/jsx-runtime").JSX.Element;
+export default ThemeToggle;

package/dist/src/common/components/ui/index.d.ts

@@ -0,0 +1,15 @@
+export { default as CenteredHeading } from './CenteredHeading/CenteredHeading';
+export { default as Scroller } from './Scroller/Scroller';
+export { default as LoadingScreen } from './LoadingScreen/LoadingScreen';
+export { default as CompoundPanel, Section } from './CompoundPanel/CompoundPanel';
+export type { SectionProps } from './CompoundPanel/CompoundPanel';
+export { ScrollerProvider, useScrollContext } from './Scroller/context/ScrollerContextProvider';
+export type { ItemCounts } from './Scroller/context/ScrollerContextProvider';
+export type { priority } from './Scroller/types';
+export { CollapsingButtons } from './CollapsingButtons/CollapsingButtons';
+export { SpeedDialButton } from './SpeedDialButton/SpeedDialButton';
+export { default as ThemeToggle } from './ThemeToggle/ThemeToggle';
+export { default as Panel } from './Panel/Main/Panel';
+export { PanelProvider, usePanelContext } from './Panel/Main/Context/PanelContextProvider';
+export type { PanelProps, PanelDimensions } from './Panel/Main/Context/PanelContextProvider';
+export * from './Panel/types';

package/dist/src/common/hooks/index.d.ts

@@ -0,0 +1 @@
+export { useRetry } from './useRetry';

package/dist/src/common/hooks/useRetry.d.ts

@@ -0,0 +1,12 @@
+interface UseRetryProps {
+    action: () => Promise<any> | void;
+    maxAttempts?: number;
+    delay?: number;
+    successMessage?: string;
+    errorMessage?: string;
+    condition?: boolean;
+}
+export declare const useRetry: ({ action, maxAttempts, delay, successMessage, errorMessage, condition, }: UseRetryProps) => {
+    attempts: number;
+};
+export {};

package/dist/src/common/index.d.ts

@@ -0,0 +1,2 @@
+export * from './components';
+export * from './hooks';