mui-toolpad-extended-tuni 2.1.0 → 3.0.0

package/dist/src/LMSToolpad/components/Navigation/NavigationRegistry.d.ts

@@ -0,0 +1,116 @@
+import { ComponentType, ReactNode, ReactElement } from 'react';
+import { SvgIconComponent } from '@mui/icons-material';
+/**
+ * Microservice Registry System
+ *
+ * @version 1.3.0
+ *
+ * A flexible system for registering and managing microservices for grid layouts.
+ * Supports dynamic registration, unregistration, and automatic re-rendering.
+ * Optimized to prevent excessive re-rendering.
+ *
+ * Now supports route providers for microservice-agnostic route registration.
+ */
+/**
+ * Route provider function that returns Route elements
+ */
+export type RouteProvider = () => ReactElement[];
+/**
+ * Microservice entry containing both the component and optional props
+ */
+export interface MicroserviceEntry {
+    Component: ComponentType<any>;
+    props?: Record<string, any>;
+    name: string;
+    description?: string;
+    category?: string;
+    iconComponent?: SvgIconComponent;
+    metadata?: {
+        keepVisible?: boolean;
+        order?: number;
+        tags?: string[];
+        showInNavigation?: boolean;
+        route?: {
+            path: string;
+            element?: ReactNode;
+            index?: boolean;
+        };
+    };
+}
+export declare const useMicroserviceRegistryStore: () => {
+    microservices: Map<string, MicroserviceEntry>;
+    routeProviders: Map<string, RouteProvider>;
+    lastUpdate: number;
+};
+/**
+ * Register a new microservice.
+ *
+ * @param id - The unique identifier for this microservice.
+ * @param Component - The React component to render.
+ * @param options - Optional configuration for the microservice including props and metadata.
+ */
+export declare function registerMicroservice(id: string, Component: ComponentType<any>, options?: {
+    props?: Record<string, any>;
+    name?: string;
+    description?: string;
+    category?: string;
+    iconComponent?: SvgIconComponent;
+    metadata?: {
+        keepVisible?: boolean;
+        order?: number;
+        tags?: string[];
+        showInNavigation?: boolean;
+        route?: {
+            path: string;
+            element?: ReactNode;
+            index?: boolean;
+        };
+    };
+}): void;
+/**
+ * Unregister a microservice.
+ *
+ * @param id - The unique identifier for the microservice to remove.
+ */
+export declare function unregisterMicroservice(id: string): void;
+/**
+ * Get a specific microservice by ID.
+ *
+ * @param id - The unique identifier for the microservice.
+ * @returns The microservice entry or undefined if not found.
+ */
+export declare function getMicroservice(id: string): MicroserviceEntry | undefined;
+/**
+ * Get all registered microservices.
+ *
+ * @returns A Map of all registered microservices.
+ */
+export declare function getAllMicroservices(): Map<string, MicroserviceEntry>;
+/**
+ * Get all microservice IDs.
+ *
+ * @returns An array of all registered microservice IDs.
+ */
+export declare function getMicroserviceIds(): string[];
+/**
+ * Check if a microservice is registered.
+ *
+ * @param id - The unique identifier for the microservice.
+ * @returns True if the microservice is registered, false otherwise.
+ */
+export declare function isMicroserviceRegistered(id: string): boolean;
+/**
+ * Register a route provider.
+ * Route providers are functions that return Route elements, allowing microservices
+ * to register complex nested route structures.
+ *
+ * @param id - The unique identifier for this route provider.
+ * @param provider - Function that returns an array of Route elements.
+ */
+export declare function registerRouteProvider(id: string, provider: RouteProvider): void;
+/**
+ * Unregister a route provider.
+ *
+ * @param id - The unique identifier for the route provider to remove.
+ */
+export declare function unregisterRouteProvider(id: string): void;

package/dist/src/LMSToolpad/components/Navigation/hooks/useMicroserviceNavigation.d.ts

@@ -0,0 +1,4 @@
+/**
+ * Hook that maintains persistent navigation entries for microservices.
+ */
+export declare const useMicroserviceNavigation: () => null;

package/dist/src/LMSToolpad/components/Navigation/hooks/useMicroserviceRoutes.d.ts

@@ -0,0 +1,6 @@
+import { ReactElement } from 'react';
+/**
+ * Hook that generates routes from registered microservices
+ * @returns Array of Route elements based on registered microservice routes
+ */
+export declare const useMicroserviceRoutes: () => ReactElement<unknown, string | import('react').JSXElementConstructor<any>>[];

package/dist/src/LMSToolpad/components/Navigation/hooks/useNavigationSectionManager.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Hook that provides a simplified interface for managing navigation sections.
+ * Abstracts away the complexity of the navigation store and filter store interaction.
+ *
+ * @returns {Object} Section management functions
+ * @property {Function} addDynamicSection - Adds or updates a section in navigation
+ */
+interface DynamicSection {
+    header: string;
+    keepVisible?: boolean;
+    pages?: Array<{
+        segment: string;
+        title: string;
+        Icon?: any;
+        description?: string;
+        instances?: string[];
+        microservices?: string[];
+    }>;
+}
+export declare const useNavigationSectionManager: () => {
+    addDynamicSection: (section: DynamicSection) => void;
+};
+export {};

package/dist/src/LMSToolpad/components/Navigation/hooks/useSyncNavigationFilters.d.ts

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

package/dist/src/LMSToolpad/components/Navigation/store/microserviceUtils.d.ts

@@ -0,0 +1,9 @@
+import { NavigationPageStoreItem, ViewStore } from './types';
+/**
+ * Aggregates microservices from all available sources (app-level + external).
+ * This is microservice-agnostic - it doesn't hard-code specific store types.
+ *
+ * @param state - The navigation store state
+ * @returns Array of all available microservice navigation items
+ */
+export declare const getAllMicroservices: (state: ViewStore) => NavigationPageStoreItem[];

package/dist/src/LMSToolpad/components/Navigation/store/navigationCalculator.d.ts

@@ -0,0 +1,11 @@
+import { NavigationStoreItem, NavigationSection } from './types';
+/**
+ * Calculates the navigation structure from sections.
+ * Pure function that takes sections, order, and visibility and returns a flat navigation array.
+ *
+ * @param sections - Record of navigation sections keyed by section key
+ * @param sectionOrder - Array of section keys in display order
+ * @param visibleSections - Record of section visibility flags
+ * @returns Flat array of navigation items for rendering
+ */
+export declare const calculateNavigationFromSections: (sections: Record<string, NavigationSection>, sectionOrder: string[], visibleSections: Record<string, boolean>) => NavigationStoreItem[];

package/dist/src/LMSToolpad/components/Navigation/store/sectionManager.d.ts

@@ -0,0 +1,9 @@
+import { ViewStore } from './types';
+/**
+ * Updates microservice navigation for all sections.
+ * Orchestrates the update process across all sections and recalculates navigation.
+ *
+ * @param state - The current navigation store state
+ * @returns Updated state with sections and navigation, or null if no changes
+ */
+export declare const updateMicroserviceNavigationForSections: (state: ViewStore) => Partial<ViewStore> | null;

package/dist/src/LMSToolpad/components/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/src/LMSToolpad/components/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/traditional').UseBoundStoreWithEqualityFn<import('zustand').StoreApi<NavigationFilterState>>;

package/dist/src/LMSToolpad/components/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/traditional').UseBoundStoreWithEqualityFn<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/src/LMSToolpad/components/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/traditional').UseBoundStoreWithEqualityFn<import('zustand').StoreApi<NotificationStore>>;
+export {};

package/dist/src/LMSToolpad/components/Routes/Home/Home.d.ts

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

package/dist/src/LMSToolpad/components/Users/Forms/UserSettings/UserSettings.d.ts

@@ -0,0 +1,22 @@
+/** @format */
+/**
+ * UserSettings Component
+ *
+ * @version 3.0.0
+ * @breaking-changes
+ * - Enhanced layout with responsive design patterns
+ * - Added platform role management with admin-only access
+ * - Improved image handling with multi-size support
+ * - Added validation for platform roles
+ * - Enhanced styling consistency with theme integration
+ * - Removed fixed height constraints for better content flow
+ *
+ * Provides interface for:
+ * - Managing user profile information
+ * - Configuring privacy settings
+ * - Managing platform roles (admin only)
+ * - Setting data retention preferences
+ * - Managing notification preferences
+ */
+declare const UserSettings: () => import("react/jsx-runtime").JSX.Element | null;
+export default UserSettings;

package/dist/src/LMSToolpad/components/Users/UserEventPublisher.d.ts

@@ -0,0 +1,8 @@
+/** @format */
+/**
+ * UserEventPublisher publishes user state changes to the UserBus.
+ * This component converts user store changes to user events and publishes them.
+ * It maintains separation by only knowing about users and the UserBus API.
+ */
+declare const UserEventPublisher: React.FC;
+export default UserEventPublisher;

package/dist/src/LMSToolpad/components/Users/UserManager.d.ts

@@ -0,0 +1,2 @@
+/** @format */
+export declare const UserManager: () => null;

package/dist/src/LMSToolpad/components/Users/UserMicroservice.d.ts

@@ -0,0 +1,34 @@
+import { default as React, ReactNode } from 'react';
+interface UserMicroserviceProps {
+    children?: ReactNode;
+}
+/**
+ * UserMicroservice Component
+ *
+ * @version 1.0.0
+ *
+ * Self-contained microservice that handles all user-related functionality:
+ * - User lifecycle management (via UserManager)
+ * - User state change publishing to UserBus (via UserEventPublisher)
+ * - User data synchronization with navigation filters
+ *
+ * Other modules should subscribe to UserBus (via hooks like useCurrentUser, useUserActions)
+ * to react to user changes. Direct useUserStore access is only allowed within the Users
+ * module itself, in Events/UserBus for delegation, and in DevTools components.
+ *
+ * This component should be used in App.tsx, not LMSProvider.tsx, to maintain
+ * proper separation of concerns and avoid tight coupling.
+ *
+ * @example
+ * ```tsx
+ * <Microservices>
+ *   <UserMicroservice />
+ *   <CalendarMicroservice />
+ *   <CourseMicroservice>
+ *     <EduTest />
+ *   </CourseMicroservice>
+ * </Microservices>
+ * ```
+ */
+declare const UserMicroservice: React.FC<UserMicroserviceProps>;
+export default UserMicroservice;

package/dist/src/LMSToolpad/components/Users/index.d.ts

@@ -0,0 +1,6 @@
+/** @format */
+export { default as UserMicroservice } from './UserMicroservice';
+export { useUserStore } from './store/useUserStore';
+export type { UserData, UserState } from './store/useUserStore';
+export { default as UserSettings } from './Forms/UserSettings/UserSettings';
+export { UserManager } from './UserManager';

package/dist/src/LMSToolpad/components/Users/mocks/constants.d.ts

@@ -0,0 +1,59 @@
+import { navigationTypes } from '../store/useUserStore';
+export declare const departmentVariants: string[];
+export declare const preferencesVariants: navigationTypes[];
+export declare const randomPerson: {
+    gender: string;
+    name: {
+        title: string;
+        first: string;
+        last: string;
+    };
+    location: {
+        street: {
+            number: number;
+            name: string;
+        };
+        city: string;
+        state: string;
+        country: string;
+        postcode: number;
+        coordinates: {
+            latitude: string;
+            longitude: string;
+        };
+        timezone: {
+            offset: string;
+            description: string;
+        };
+    };
+    email: string;
+    login: {
+        uuid: string;
+        username: string;
+        password: string;
+        salt: string;
+        md5: string;
+        sha1: string;
+        sha256: string;
+    };
+    dob: {
+        date: string;
+        age: number;
+    };
+    registered: {
+        date: string;
+        age: number;
+    };
+    phone: string;
+    cell: string;
+    id: {
+        name: string;
+        value: string;
+    };
+    picture: {
+        large: string;
+        medium: string;
+        thumbnail: string;
+    };
+    nat: string;
+};

package/dist/src/LMSToolpad/components/Users/mocks/endpoints.d.ts

@@ -0,0 +1,3 @@
+import { HttpResponse } from 'msw';
+export declare const userHandlers: import('msw').HttpHandler[];
+export declare const getUserDataResponse: (userId?: string) => HttpResponse;

package/dist/src/LMSToolpad/components/Users/mocks/generators.d.ts

@@ -0,0 +1,6 @@
+import { UserBackendData } from './types';
+export declare function generateUsers(config: {
+    teacherCount: number;
+    studentCount: number;
+    adminCount: number;
+}): Promise<UserBackendData[]>;

package/dist/src/LMSToolpad/components/Users/mocks/types.d.ts

@@ -0,0 +1,52 @@
+import { PlatformRole } from '../../../store/usePlatformStore';
+import { navigationTypes } from '../store/useUserStore';
+import { randomPerson } from './constants';
+export interface UserRawBackendData {
+    name: string;
+    email: string;
+    image?: {
+        large: string;
+        medium: string;
+        thumbnail: string;
+    };
+    department?: string;
+    platform_roles: PlatformRole[];
+    privacy_settings: {
+        allow_analytics: boolean;
+        allow_personalization: boolean;
+        allow_communications: boolean;
+        allow_third_party_sharing: boolean;
+    };
+    gdpr_consent: {
+        accepted: boolean;
+        accepted_date?: string;
+        last_updated: string;
+    };
+    data_retention: {
+        delete_account_after_inactivity?: number;
+        delete_data_after_account_deletion?: number;
+    };
+    preferences: {
+        navigation_type: navigationTypes;
+        visible_course_lists: {
+            is_student: boolean;
+            is_student_old: boolean;
+            is_teacher: boolean;
+            is_teacher_old: boolean;
+            available: boolean;
+        };
+        visible_navigation: string[];
+        last_visited_courses: string[];
+    };
+}
+export interface UserBackendData extends UserRawBackendData {
+    id: string;
+    created_at: string;
+    updated_at: string;
+}
+export type UserCourseConnection = {
+    userId: string;
+    courseId: string;
+    role: "teacher" | "student";
+};
+export type randomPersonFromApi = typeof randomPerson;

package/dist/src/LMSToolpad/components/Users/network/users.d.ts

@@ -0,0 +1,7 @@
+import { UserData } from '../store/useUserStore';
+export declare const getCurrentUser: () => Promise<UserData>;
+export declare const getUsers: (courseId?: string) => Promise<UserData[]>;
+export declare const createUser: (userData: Partial<UserData>) => Promise<UserData>;
+export declare const updateUser: (userData: UserData) => Promise<UserData>;
+export declare const deleteUser: (userId: string) => Promise<void>;
+export declare const logoutUser: () => Promise<void>;

package/dist/src/LMSToolpad/components/Users/store/useUserStore.d.ts

@@ -0,0 +1,63 @@
+import { fetchState } from '../../../interfaces';
+import { PlatformRole } from '../../../store/usePlatformStore';
+export type userId = string;
+export type navigationTypes = "direct" | "instances";
+export type gender = "male" | "female" | "other";
+export interface UserData {
+    id: userId;
+    name: string;
+    email: string;
+    gender?: gender;
+    image?: {
+        large: string;
+        medium: string;
+        thumbnail: string;
+    };
+    department?: string;
+    platformRoles: PlatformRole[];
+    privacySettings: {
+        allowAnalytics: boolean;
+        allowPersonalization: boolean;
+        allowCommunications: boolean;
+        allowThirdPartySharing: boolean;
+    };
+    gdprConsent: {
+        accepted: boolean;
+        acceptedDate?: string;
+        lastUpdated: string;
+    };
+    dataRetention: {
+        deleteAccountAfterInactivity?: number;
+        deleteDataAfterAccountDeletion?: number;
+    };
+    preferences: {
+        navigationType: navigationTypes;
+        visibleCourseLists: {
+            isStudent: boolean;
+            isStudentOld: boolean;
+            isTeacher: boolean;
+            isTeacherOld: boolean;
+            available: boolean;
+        };
+        lastVisitedCourses: string[];
+        visibleNavigation: string[];
+    };
+}
+export interface UserState {
+    fetchState: fetchState;
+    user: UserData | null;
+    userToUpdate: UserData | null;
+    testUsers: UserData[];
+    users: UserData[];
+    courseUsers?: UserData[];
+    setUserToUpdate: (user: UserData | null) => void;
+    setUser: (user: UserData) => void;
+    setTestUsers: (users: UserData[]) => void;
+    getUser: () => void;
+    clearUser: () => void;
+    getUsers: () => void;
+    fetchCourseUsers: (courseId: string) => Promise<void>;
+    logout: () => Promise<void>;
+    updateUser: (userData: UserData) => Promise<UserData>;
+}
+export declare const useUserStore: import('zustand/traditional').UseBoundStoreWithEqualityFn<import('zustand').StoreApi<UserState>>;

package/dist/{LMSToolpad → src/LMSToolpad}/components/tools/addActions.d.ts

@@ -1,5 +1,5 @@
-import { NavigationStoreItem } from "../../store/useNavigationStore";
+import { NavigationStoreItem } from '../Navigation/store/useNavigationStore';
 /**
  * Adds actions to navigation items based on their actionHandlers
  */
-export declare const addActions: (navItems: NavigationStoreItem[], role: string) => NavigationStoreItem[];
+export declare const addActions: (navItems: NavigationStoreItem[]) => NavigationStoreItem[];

package/dist/{LMSToolpad → src/LMSToolpad}/components/tools/addIcons.d.ts

@@ -1,2 +1,2 @@
-import { NavigationStoreItem } from "../../store/useNavigationStore";
+import { NavigationStoreItem } from '../Navigation/store/useNavigationStore';
 export declare const addIcons: (navItems: NavigationStoreItem[]) => NavigationStoreItem[];

package/dist/{LMSToolpad → src/LMSToolpad}/components/tools/utils/ActionFCWrapper.d.ts

@@ -1,5 +1,5 @@
-declare const ActionFCWrapper: <T extends Record<string, unknown>>({ ActionHandler, props }: {
-    ActionHandler: import("react").FC<T>;
+declare const ActionFCWrapper: <T extends Record<string, unknown>>({ ActionHandler, props, }: {
+    ActionHandler: React.FC<T>;
     props: T;
 }) => import("react/jsx-runtime").JSX.Element;
 export default ActionFCWrapper;