@mui-toolpad-extended-tuni/core 3.0.0

package/dist/Navigation/store/types.d.ts

@@ -0,0 +1,90 @@
+import { SvgIconComponent } from '@mui/icons-material';
+import { default as React } from 'react';
+export interface NavigationItemBase {
+    kind: "header" | "page" | "divider";
+    title?: string;
+    actionFC?: React.FC;
+}
+export interface ToolMetadata {
+    description?: string;
+    forRoles?: string[];
+    isRootTool?: boolean;
+    underHeader?: string;
+    microservices?: string[];
+}
+export interface NavigationHeaderItem extends NavigationItemBase {
+    kind: "header";
+    title: string;
+}
+export interface NavigationDividerItem extends NavigationItemBase {
+    kind: "divider";
+}
+export interface NavigationPageStoreItem extends NavigationItemBase {
+    kind: "page";
+    segment: string;
+    iconFC?: SvgIconComponent;
+    icon?: React.ReactElement;
+    children?: NavigationPageStoreItem[];
+    view?: React.ComponentType;
+    action?: React.ReactElement;
+    showTitle?: boolean;
+    metadata?: ToolMetadata;
+}
+export type NavigationStoreItem = NavigationHeaderItem | NavigationPageStoreItem | NavigationDividerItem;
+/**
+ * Updated addSectionProps type.
+ * Now you provide a header (underHeader) and an array of page configs.
+ */
+export type addSectionProps = {
+    underHeader: string;
+    keepVisible?: boolean;
+    pages: Array<{
+        segment: string;
+        title: string;
+        Icon?: SvgIconComponent;
+        description?: string;
+        instances?: string[];
+        microservices?: string[];
+        actionFC?: React.FC;
+    }>;
+};
+/**
+ * New interface for a navigation section.
+ * Each section is keyed by its header (or unique id) and contains:
+ *  - header: the header item (NavigationHeaderItem)
+ *  - pages: a dictionary of pages keyed by their segment
+ *  - pageOrder: an array of page keys (segments) to preserve ordering
+ */
+export interface NavigationSection {
+    header: NavigationHeaderItem;
+    pages: Record<string, NavigationPageStoreItem>;
+    pageOrder: string[];
+}
+export type ViewStore = {
+    navigation: NavigationStoreItem[];
+    sections: Record<string, NavigationSection>;
+    sectionOrder: string[];
+    /**
+     * App-level microservice navigation items only.
+     * These are typically registered via NavigationRegistry for app-level routes.
+     */
+    allMicroserviceNavigation: NavigationPageStoreItem[];
+    addSection: (props: addSectionProps) => void;
+    removeHeader: (header: string) => void;
+    addMicroserviceNavigation: (microserviceNavigation: NavigationPageStoreItem) => void;
+    addStandaloneNavigation: (navigation: NavigationPageStoreItem) => void;
+    updateMicroserviceNavigationForSections: () => void;
+    recalculateNavigation: () => void;
+    visibleSections: Record<string, boolean>;
+    setVisibleSections: (options: Record<string, boolean>) => void;
+    collapsedSections: Record<string, boolean>;
+    setCollapsedSections: (options: Record<string, boolean>) => void;
+    toggleSectionCollapse: (sectionKey: string) => void;
+    /**
+     * Externally registered microservice navigation items.
+     * These are provided by external components (like CourseMicroservice) via setExternalMicroservices.
+     * The store is microservice-agnostic - it doesn't know or care about specific microservice types.
+     */
+    externalMicroservices: NavigationPageStoreItem[];
+    setExternalMicroservices: (microservices: NavigationPageStoreItem[]) => void;
+};

package/dist/Navigation/store/useNavigationFilterStore.d.ts

@@ -0,0 +1,6 @@
+export interface NavigationFilterState {
+    filterOptions: Record<string, boolean>;
+    setFilterOptions: (optionsOrUpdater: Record<string, boolean> | ((prev: Record<string, boolean>) => Record<string, boolean>)) => void;
+    initializeFilters: () => void;
+}
+export declare const useNavigationFilterStore: import('zustand').UseBoundStore<import('zustand').StoreApi<NavigationFilterState>>;

package/dist/Navigation/store/useNavigationStore.d.ts

@@ -0,0 +1,50 @@
+import { NavigationStoreItem, ViewStore } from './types';
+/**
+ * Navigation management store with enhanced section management and filtering capabilities.
+ *
+ * @version 3.1.0
+ * @updates
+ * - Complete rewrite of navigation structure using sections
+ * - Added section-based visibility filtering
+ * - Enhanced microservice integration with automatic updates
+ * - Added support for dividers in navigation
+ * - Introduced flexible section management with ordered headers
+ * - Added action components support in navigation items
+ * - Clear separation: app-level navigation only (course microservices handled separately)
+ * - Refactored: Extracted types, utilities, and complex logic into separate modules
+ *
+ * @breaking-changes
+ * - Removed updateSection and updateCourseInstanceSection methods
+ * - Changed addSection API to use header-based organization
+ * - Sections are now managed through a structured record instead of flat array
+ * - Navigation items require explicit header assignment
+ * - Changed microservice update mechanism to be section-aware
+ *
+ * @scope
+ * This store handles navigation for the application:
+ * - Global sections (Help, Contact, etc.)
+ * - App-level microservices registered via NavigationRegistry
+ * - External microservices provided via setExternalMicroservices (e.g., from CourseMicroservice)
+ *
+ * @structure
+ * Navigation is now organized into sections:
+ * - Each section has a header, pages, and maintained order
+ * - Pages can have nested children (for instances or microservices)
+ * - Sections can be individually shown/hidden through visibleSections
+ *
+ * @example
+ * ```typescript
+ * useNavigationStore.getState().addSection({
+ *   underHeader: "Courses",
+ *   pages: [{
+ *     segment: "course-1",
+ *     title: "Course 1",
+ *     description: "Example course",
+ *     microservices: ["attendance", "grades"]
+ *   }]
+ * });
+ * ```
+ */
+export declare const useNavigationStore: import('zustand').UseBoundStore<import('zustand').StoreApi<ViewStore>>;
+export declare const filterNavigationByRole: (role: string) => NavigationStoreItem[];
+export type { NavigationItemBase, ToolMetadata, NavigationHeaderItem, NavigationDividerItem, NavigationPageStoreItem, NavigationStoreItem, addSectionProps, NavigationSection, } from './types';

package/dist/Notifications/Notifications.d.ts

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

package/dist/Notifications/store/useNotificationsStore.d.ts

@@ -0,0 +1,22 @@
+/** @format */
+export type NotificationRaw = {
+    type: string;
+    message: string;
+    singular?: boolean;
+    singularId?: string;
+};
+export type Notification = {
+    type: string;
+    message: string;
+    id: string;
+    singular?: boolean;
+    singularId?: string;
+};
+type NotificationStore = {
+    notifications: Notification[] | [];
+    addNotificationData: (notificationData: NotificationRaw) => void;
+    removeNotificationData: (notificationId: number) => void;
+    clearNotificationsByType: (type: string) => void;
+};
+export declare const useNotificationStore: import('zustand').UseBoundStore<import('zustand').StoreApi<NotificationStore>>;
+export {};

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

@@ -0,0 +1,2 @@
+export * from './ui';
+export * from './layout';

package/dist/common/components/layout/GridLayout/GridItem.d.ts

@@ -0,0 +1,17 @@
+import { default as React, ReactNode } from 'react';
+export interface GridItemProps {
+    children: ReactNode;
+    id: string;
+    isFlexContainer?: boolean;
+}
+/**
+ * Grid item component that applies consistent styling and resize visual feedback.
+ *
+ * Features:
+ * - Visual indication when in resize or move mode
+ * - Consistent styling for all grid items
+ * - Optional flex container for content that needs to fill the space
+ * - Content is non-interactable when in edit mode (using BlurOverlay)
+ */
+declare const GridItem: React.FC<GridItemProps>;
+export default GridItem;

package/dist/common/components/layout/GridLayout/GridItemContext.d.ts

@@ -0,0 +1,26 @@
+import { default as React, ReactNode } from 'react';
+import { Layout } from 'react-grid-layout';
+export interface GridItem {
+    id: string;
+    content: ReactNode;
+    layout?: Layout;
+}
+export interface GridItemEntry {
+    id: string;
+    content: ReactNode;
+    layout?: Layout;
+}
+interface GridItemContextType {
+    gridItems: GridItemEntry[];
+    registerGridItem: (id: string, content: ReactNode, layout?: Layout) => void;
+    unregisterGridItem: (id: string) => void;
+    getGridItem: (id: string) => GridItemEntry | undefined;
+    getAllGridItems: () => GridItemEntry[];
+}
+declare const GridItemContext: React.Context<GridItemContextType | undefined>;
+export declare const useGridItemContext: () => GridItemContextType;
+interface GridItemProviderProps {
+    children: ReactNode;
+}
+export declare const GridItemProvider: React.FC<GridItemProviderProps>;
+export default GridItemContext;

package/dist/common/components/layout/GridLayout/ResponsiveGridLayout.d.ts

@@ -0,0 +1,16 @@
+import { default as React, ReactNode } from 'react';
+import { Layout } from 'react-grid-layout';
+export interface GridItem {
+    id: string;
+    content: ReactNode;
+    layout?: Layout;
+}
+export interface GridLayoutProps {
+    items: GridItem[];
+    storageKey: string;
+    defaultLayouts: {
+        [key: string]: Layout[];
+    };
+}
+declare const ResponsiveGridLayout: React.FC<GridLayoutProps>;
+export default ResponsiveGridLayout;

package/dist/common/components/layout/GridLayout/Tools/BreakpointIndicator.d.ts

@@ -0,0 +1,8 @@
+import { default as React } from 'react';
+/**
+ * Shows which responsive breakpoint is currently active
+ */
+declare const BreakpointIndicator: React.FC<{
+    showLabel?: boolean;
+}>;
+export default BreakpointIndicator;

package/dist/common/components/layout/GridLayout/Tools/EditModeToggler.d.ts

@@ -0,0 +1,7 @@
+/** @format */
+/**
+ * Toggles edit mode for the grid layout system.
+ * This activates both resize and move functionality at once.
+ */
+declare const EditModeToggler: () => import("react/jsx-runtime").JSX.Element;
+export default EditModeToggler;

package/dist/common/components/layout/GridLayout/hooks/useGridLayoutManagement.d.ts

@@ -0,0 +1,27 @@
+import { Layout, Layouts } from 'react-grid-layout';
+/**
+ * Options for the useGridLayoutManagement hook
+ */
+interface UseGridLayoutManagementOptions {
+    /** Storage key for persisting layouts */
+    storageKey: string;
+    /** Default layouts to use if none found in storage */
+    defaultLayouts: Layouts;
+    /** Function to run when layout changes */
+    onLayoutChangeCallback?: (layouts: Layouts) => void;
+    /** Debounce time for saving to localStorage (ms) */
+    debounceTime?: number;
+}
+/**
+ * Hook for managing grid layouts, including persistence, updates, and preset handling
+ *
+ * @param options Configuration options
+ * @returns Layout management utilities
+ */
+export declare function useGridLayoutManagement({ storageKey, defaultLayouts, onLayoutChangeCallback, debounceTime, }: UseGridLayoutManagementOptions): {
+    layouts: Layouts;
+    onLayoutChange: (_: Layout[], allLayouts: Layouts) => void;
+    applyLayout: (newLayouts: Layouts) => void;
+    resetToDefault: () => void;
+};
+export {};

package/dist/common/components/layout/GridLayout/index.d.ts

@@ -0,0 +1,12 @@
+/** @format */
+export * from './GridItemContext';
+export * from './layoutUtils';
+export { default as GridItem } from './GridItem';
+export { default as ResponsiveGridLayout } from './ResponsiveGridLayout';
+export type { GridItem as GridItemType, GridLayoutProps } from './ResponsiveGridLayout';
+export { default as useGridLayout } from './useGridLayout';
+export * from './layoutStorageUtils';
+export * from './hooks/useGridLayoutManagement';
+export { default as EditModeToggler } from './Tools/EditModeToggler';
+export { default as BreakpointIndicator } from './Tools/BreakpointIndicator';
+export * from './store/usePanelStore';

package/dist/common/components/layout/GridLayout/layoutStorageUtils.d.ts

@@ -0,0 +1,52 @@
+import { Layouts } from 'react-grid-layout';
+/**
+ * Helper function to get layout from localStorage
+ * @param key Storage key for the layout
+ * @returns The stored layout or null if not found
+ */
+export declare function getFromLS(key: string): Layouts | null;
+/**
+ * Helper function to save layout to localStorage
+ * @param key Storage key for the layout
+ * @param value The layout to store
+ */
+export declare function saveToLS(key: string, value: Layouts): void;
+export declare const USER_PRESETS_KEY = "user-layout-presets";
+/**
+ * Layout preset interface
+ */
+export interface LayoutPreset {
+    id: string;
+    name: string;
+    layouts: Layouts;
+    createdAt?: number;
+    updatedAt?: number;
+}
+/**
+ * Helper function to get user presets from localStorage
+ * @returns Array of user-defined layout presets
+ */
+export declare function getUserPresets(): LayoutPreset[];
+/**
+ * Helper function to save a user preset to localStorage
+ * @param name Name of the preset
+ * @param layouts Layout configuration to save
+ * @returns ID of the newly created preset
+ */
+export declare function saveUserPreset(name: string, layouts: Layouts): string;
+/**
+ * Helper function to delete a user preset from localStorage
+ * @param presetId ID of the preset to delete
+ * @returns true if deletion was successful, false otherwise
+ */
+export declare function deleteUserPreset(presetId: string): boolean;
+/**
+ * Helper function to update a user preset in localStorage
+ * @param presetId ID of the preset to update
+ * @param updates Object with properties to update
+ * @returns true if update was successful, false otherwise
+ */
+export declare function updateUserPreset(presetId: string, updates: Partial<{
+    name: string;
+    layouts: Layouts;
+}>): boolean;

package/dist/common/components/layout/GridLayout/layoutUtils.d.ts

@@ -0,0 +1,78 @@
+import { Layout } from 'react-grid-layout';
+/**
+ * Options for creating a grid item layout.
+ * All properties are optional, allowing for flexible grid item creation.
+ */
+export interface CreateGridItemOptions {
+    /**
+     * Unique identifier for the grid item.
+     * If not provided, a unique ID will be generated.
+     */
+    id?: string;
+    /**
+     * X position in the grid (column index).
+     * Defaults to 0 if not specified.
+     */
+    x?: number;
+    /**
+     * Y position in the grid (row index).
+     * Defaults to 0 if not specified.
+     */
+    y?: number;
+    /**
+     * Width of the grid item in grid units.
+     * If null, the item will span the full width of the grid.
+     * Defaults to 1 if not specified.
+     */
+    w?: number | null;
+    /**
+     * Height of the grid item in grid units.
+     * Defaults to 1 if not specified.
+     */
+    h?: number | null;
+    /**
+     * Minimum width constraint.
+     * Defaults to 1 if not specified.
+     */
+    minW?: number;
+    /**
+     * Maximum width constraint.
+     * If null, no maximum width constraint.
+     */
+    maxW?: number | null;
+    /**
+     * Minimum height constraint.
+     * Defaults to 1 if not specified.
+     */
+    minH?: number;
+    /**
+     * Maximum height constraint.
+     * If null, no maximum height constraint.
+     */
+    maxH?: number | null;
+    /**
+     * Whether the item is static (cannot be moved or resized).
+     * Defaults to false.
+     */
+    static?: boolean;
+}
+/**
+ * Creates a grid item layout configuration.
+ *
+ * @example
+ * // Create a grid item with default settings
+ * createGridItem({ id: "my-item" });
+ *
+ * @example
+ * // Create a grid item with specific dimensions
+ * createGridItem({ id: "my-item", x: 0, y: 0, w: 7, h: 5 });
+ *
+ * @example
+ * // Create a full-width grid item
+ * createGridItem({
+ *   id: "my-item",
+ *   w: null, // null means full width
+ *   h: 5
+ * });
+ */
+export declare function createGridItem(options: CreateGridItemOptions): Layout;

package/dist/common/components/layout/GridLayout/store/usePanelStore.d.ts

@@ -0,0 +1,27 @@
+/** @format */
+interface PanelState {
+    editMode: boolean;
+    toggleEditMode: () => void;
+    resizeMode: boolean;
+    toggleResizeMode: () => void;
+    moveMode: boolean;
+    toggleMoveMode: () => void;
+}
+/**
+ * Store for managing panel state related to grid layouts.
+ *
+ * This uses a single editMode that enables both dragging and resizing.
+ * It also manages saved layout presets.
+ */
+export declare const usePanelStore: import('zustand').UseBoundStore<Omit<import('zustand').StoreApi<PanelState>, "persist"> & {
+    persist: {
+        setOptions: (options: Partial<import('zustand/middleware').PersistOptions<PanelState, PanelState>>) => void;
+        clearStorage: () => void;
+        rehydrate: () => Promise<void> | void;
+        hasHydrated: () => boolean;
+        onHydrate: (fn: (state: PanelState) => void) => () => void;
+        onFinishHydration: (fn: (state: PanelState) => void) => () => void;
+        getOptions: () => Partial<import('zustand/middleware').PersistOptions<PanelState, PanelState>>;
+    };
+}>;
+export default usePanelStore;

package/dist/common/components/layout/GridLayout/useGridLayout.d.ts

@@ -0,0 +1,11 @@
+/** @format */
+/**
+ * Hook to manage grid layout state
+ *
+ * @returns Object containing grid layout state and actions
+ */
+declare const useGridLayout: () => {
+    editMode: boolean;
+    toggleEditMode: () => void;
+};
+export default useGridLayout;

package/dist/common/components/layout/index.d.ts

@@ -0,0 +1 @@
+export * from './GridLayout';

package/dist/common/components/ui/CenteredHeading/CenteredHeading.d.ts

@@ -0,0 +1,7 @@
+/** @format */
+type CenteredHeadingProps = {
+    heading: string;
+    subheading?: string;
+};
+declare const CenteredHeading: ({ heading, subheading }: CenteredHeadingProps) => import("react/jsx-runtime").JSX.Element;
+export default CenteredHeading;

package/dist/common/components/ui/CollapsingButtons/CollapsingButtons.d.ts

@@ -0,0 +1,11 @@
+import { default as React } from 'react';
+interface CollapsingButtonsProps {
+    collapseIcon: React.ReactNode;
+    children: React.ReactNode;
+    collapseWidth: number;
+    delay?: number;
+    tooltipTitle?: string;
+    fullWidth?: boolean;
+}
+export declare const CollapsingButtons: ({ collapseIcon, children, collapseWidth, delay, tooltipTitle, fullWidth, }: CollapsingButtonsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/common/components/ui/CompoundPanel/CompoundPanel.d.ts

@@ -0,0 +1,86 @@
+import { default as React } from 'react';
+import { PanelProps } from '../Panel/Main/Context/PanelContextProvider';
+export interface CompoundPanelProps extends PanelProps {
+    /**
+     * Content to be displayed in the panel
+     */
+    children: React.ReactNode;
+    /**
+     * Whether the panel should display in a horizontal scroller
+     */
+    horizontalScroll?: boolean;
+    /**
+     * Whether the panel should display in a vertical scroller
+     */
+    verticalScroll?: boolean;
+    /**
+     * Optional title for the panel's horizontal scroller
+     */
+    title?: string;
+    /**
+     * Priority level for title styling
+     */
+    priority?: "high" | "low" | "normal";
+    /**
+     * Automatically arrange children as sections (useful for course sections)
+     * Each direct child will be rendered as a horizontal section inside a vertical scroller
+     */
+    sections?: boolean;
+}
+/**
+ * CompoundPanel - An all-in-one panel component that encapsulates all functionality
+ * needed for panels in the LMS system, including scrolling, expanding, and resizing.
+ *
+ * @example - Simple scrolling panel
+ * ```tsx
+ * <CompoundPanel
+ *   id="my-panel"
+ *   defaultWidth={300}
+ *   defaultHeight={200}
+ *   horizontalScroll={true}
+ *   title="My Panel"
+ * >
+ *   <Item1 />
+ *   <Item2 />
+ * </CompoundPanel>
+ * ```
+ *
+ * @example - Sectioned panel (auto-creates horizontal sections within vertical scroll)
+ * ```tsx
+ * <CompoundPanel
+ *   id="sections-panel"
+ *   sections={true}
+ * >
+ *   <Section title="Section 1" priority="high">
+ *     <Item1 />
+ *     <Item2 />
+ *   </Section>
+ *   <Section title="Section 2">
+ *     <Item3 />
+ *     <Item4 />
+ *   </Section>
+ * </CompoundPanel>
+ * ```
+ */
+export declare const CompoundPanel: React.FC<CompoundPanelProps>;
+export interface SectionProps {
+    title?: string;
+    priority?: "high" | "low" | "normal";
+    children: React.ReactNode;
+}
+/**
+ * Section - A component that defines a horizontal section within a CompoundPanel.
+ * Used with CompoundPanel's sections={true} property.
+ *
+ * @example
+ * ```tsx
+ * <CompoundPanel sections={true}>
+ *   <Section title="My Section" priority="high">
+ *     <Item1 />
+ *     <Item2 />
+ *   </Section>
+ * </CompoundPanel>
+ * ```
+ */
+export declare const Section: React.FC<SectionProps>;
+export default CompoundPanel;

package/dist/common/components/ui/LoadingScreen/LoadingScreen.d.ts

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

package/dist/common/components/ui/Panel/Expandable/Expandable.d.ts

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

package/dist/common/components/ui/Panel/Expandable/context/ExpandableContextProvider.d.ts

@@ -0,0 +1,10 @@
+import { default as React, ReactNode } from 'react';
+interface ExpandableContextType {
+    isExpanded: boolean;
+    setIsExpanded: React.Dispatch<React.SetStateAction<boolean>>;
+}
+export declare const ExpandableContextProvider: ({ children, }: {
+    children: ReactNode;
+}) => import("react/jsx-runtime").JSX.Element;
+export declare const useExpandableContext: () => ExpandableContextType;
+export {};

package/dist/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/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/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/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/common/components/ui/Panel/Expandable/hooks/useResizeHandler.d.ts

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

package/dist/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').UseBoundStore<import('zustand').StoreApi<ExpandablePanelState>>;
+export {};