mui-toolpad-extended-tuni 2.0.0 → 3.0.0

package/dist/src/LMSToolpad/components/Courses/CourseInstanceSelector.d.ts

@@ -0,0 +1,15 @@
+/** @format */
+/**
+ * Component for selecting course instances from a filtered list.
+ *
+ * @version 2.1.0
+ * @new-component
+ * - Provides instance selection UI for courses
+ * - Groups instances by course code
+ * - Handles active/inactive instance states
+ * - Supports nested navigation structure
+ *
+ * @param {Course[]} courses - Available course instances
+ */
+declare const CourseInstanceSelector: () => import("react/jsx-runtime").JSX.Element;
+export default CourseInstanceSelector;

package/dist/src/LMSToolpad/components/Courses/CourseItem/CourseActions.d.ts

@@ -0,0 +1,6 @@
+/** @format */
+type CourseActionsProps = {
+    showEnrollmentOpen: boolean;
+};
+export declare const CourseActions: ({ showEnrollmentOpen }: CourseActionsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/LMSToolpad/components/Courses/CourseItem/CourseHeader.d.ts

@@ -0,0 +1,6 @@
+import { Course } from '../store/useCourseStore';
+type CourseHeaderProps = {
+    course: Course;
+};
+export declare const CourseHeader: ({ course }: CourseHeaderProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/LMSToolpad/components/Courses/CourseItem/CourseHeaderActions.d.ts

@@ -0,0 +1,12 @@
+import { Course } from '../store/useCourseStore';
+type CourseHeaderActionsProps = {
+    course: Course;
+    courseColor: string;
+    isTeacher: boolean;
+    showEnrollmentOpen?: boolean;
+    onSettingsClick: (e: React.MouseEvent<HTMLElement>) => void;
+    onEnroll?: (e: React.MouseEvent<HTMLElement>) => void;
+    onTeacherEnroll?: (e: React.MouseEvent<HTMLElement>) => void;
+};
+export declare const CourseHeaderActions: ({ course, courseColor, isTeacher, showEnrollmentOpen, onSettingsClick, onEnroll, onTeacherEnroll, }: CourseHeaderActionsProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/LMSToolpad/components/Courses/CourseItem/CourseIcon.d.ts

@@ -0,0 +1,8 @@
+import { SvgIconComponent } from '@mui/icons-material';
+export interface SubjectConfig {
+    icon: string;
+    baseColor: string;
+    levelShades: Record<string, string>;
+}
+export declare const createCourseIcon: (courseColor: string, config: SubjectConfig) => SvgIconComponent;
+export default createCourseIcon;

package/dist/src/LMSToolpad/components/Courses/CourseItem/CourseInfo.d.ts

@@ -0,0 +1,8 @@
+import { Course } from '../store/useCourseStore';
+type CourseInfoProps = {
+    course: Course;
+    displayMode: "course" | "instance" | "instanceList";
+    hasUpcomingEvents: boolean;
+};
+export declare const CourseInfo: ({ course, displayMode, hasUpcomingEvents, }: CourseInfoProps) => import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/LMSToolpad/components/Courses/CourseItem/CourseItem.d.ts

@@ -0,0 +1,9 @@
+import { Course } from '../store/useCourseStore';
+type CourseItemProps = {
+    course: Course;
+    isSelected?: boolean;
+    displayMode?: "course" | "instance" | "instanceList";
+    onClick: (course: Course) => void;
+};
+declare const CourseItem: ({ course, displayMode, onClick, }: CourseItemProps) => import("react/jsx-runtime").JSX.Element;
+export default CourseItem;

package/dist/src/LMSToolpad/components/Courses/CourseList.d.ts

@@ -0,0 +1,6 @@
+type CourseListProps = {
+    displayMode?: "course" | "instance" | "instanceList";
+    containerHeight?: string | number;
+};
+declare const CourseList: ({ displayMode, containerHeight, }: CourseListProps) => import("react/jsx-runtime").JSX.Element;
+export default CourseList;

package/dist/src/LMSToolpad/components/Courses/CourseManager.d.ts

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

package/dist/src/LMSToolpad/components/Courses/CourseMicroservice.d.ts

@@ -0,0 +1,42 @@
+import { default as React, ReactNode } from 'react';
+interface CourseMicroserviceProps {
+    children?: ReactNode;
+}
+/**
+ * CourseMicroservice Component
+ *
+ * @version 3.0.0
+ *
+ * Fully self-contained microservice that handles all course-related functionality:
+ * - Course data fetching and management (via CourseManager)
+ * - Course navigation building
+ * - Course code and instance routing (/:code, /:code/:instance)
+ * - Course tools display
+ * - Course microservice registration and routing (/:code/:instance/:microservice)
+ * - Route registration with NavigationRegistry (via CourseRoutesProvider)
+ *
+ * Course microservices (like EduTest) are passed as children and register
+ * themselves through the CourseMicroserviceContext.
+ *
+ * Routes handled:
+ * - /:code - Course code selection (CourseCodeLoader + CourseInstanceSelector)
+ * - /:code/:instance - Course instance (CourseInstanceLoader + CourseTools)
+ * - /:code/:instance/:microservice/* - Course microservice routes
+ *
+ * @breaking-changes
+ * - v3.0.0: Now fully self-contained - includes CourseManager and CourseRoutesProvider
+ * - v2.0.0: Uses local state instead of Zustand store
+ * - Context provides allCourseMicroserviceNavigation array
+ * - Integrates with useNavigationStore to notify about course microservices
+ * - v3.1.0: Context logic extracted to separate context file
+ *
+ * @example
+ * ```tsx
+ * <CourseMicroservice>
+ *   <EduTest />
+ *   <EduTest2 />
+ * </CourseMicroservice>
+ * ```
+ */
+declare const CourseMicroservice: React.FC<CourseMicroserviceProps>;
+export default CourseMicroservice;

package/dist/src/LMSToolpad/components/Courses/CourseRoutesProvider.d.ts

@@ -0,0 +1,12 @@
+/** @format */
+/**
+ * CourseRoutesProvider Component
+ *
+ * Registers course routes with the NavigationRegistry as a route provider.
+ * This allows Microservices.tsx to be microservice-agnostic - it doesn't need
+ * to know about course routes specifically.
+ *
+ * @version 1.0.0
+ */
+declare const CourseRoutesProvider: () => null;
+export default CourseRoutesProvider;

package/dist/src/LMSToolpad/components/Courses/CourseTools.d.ts

@@ -0,0 +1,21 @@
+import { NavigationPageStoreItem } from '@toolpad/core';
+interface CourseToolsProps {
+    microservices?: NavigationPageStoreItem[];
+}
+/**
+ * Component for managing and displaying course-specific tools.
+ *
+ * @version 2.1.0
+ * @updates
+ * - Added support for microservice-based tool management
+ * - Introduced enabled/available tools separation
+ * - Added service enablement/disablement functionality
+ * - Enhanced teacher-specific tool configuration
+ * - Improved UI with centered headings and tool groups
+ *
+ * @component
+ * @param {CourseToolsProps} props
+ * @param {NavigationPageStoreItem[]} props.microservices - Array of available microservice tools
+ */
+declare const CourseTools: ({ microservices }: CourseToolsProps) => import("react/jsx-runtime").JSX.Element;
+export default CourseTools;

package/dist/src/LMSToolpad/components/Courses/Forms/CourseSettings/CourseSettings.d.ts

@@ -0,0 +1,23 @@
+/** @format */
+/**
+ * CourseSettings Component
+ *
+ * @version 3.0.0
+ * @breaking-changes
+ * - Restructured import paths to follow feature-based organization
+ * - Enhanced notification handling through dedicated store
+ * - Improved dialog management with better state handling
+ * - Updated course store integration with new path structure
+ * - Enhanced TypeScript strict mode compliance
+ * - Standardized string literals for consistency
+ *
+ * Provides interface for:
+ * - Managing course basic information
+ * - Configuring course visibility
+ * - Managing enrollment settings
+ * - Configuring staff access
+ * - Setting data processing preferences
+ * - Managing course relationships
+ */
+declare const CourseSettings: () => import("react/jsx-runtime").JSX.Element;
+export default CourseSettings;

package/dist/src/LMSToolpad/components/Courses/Forms/CourseSettings/CourseSettingsTabs.d.ts

@@ -0,0 +1,9 @@
+import { CourseRaw } from '../../store/useCourseStore';
+import { UserData } from '../../../../components/Events/userTypes';
+type CourseSettingsProps = {
+    formData: CourseRaw;
+    handleUpdateFormData: (newData: CourseRaw) => void;
+    courseUsers?: UserData[];
+};
+export default function CourseSettingsTabs({ formData, handleUpdateFormData, courseUsers, }: CourseSettingsProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/LMSToolpad/components/Courses/Forms/CourseSettings/tabs/BasicInfoTab.d.ts

@@ -0,0 +1,7 @@
+import { CourseRaw } from '../../../store/useCourseStore';
+interface BasicInfoTabProps {
+    formData: CourseRaw;
+    setFormData: (data: CourseRaw) => void;
+}
+export default function BasicInfoTab({ formData, setFormData, }: BasicInfoTabProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/LMSToolpad/components/Courses/Forms/CourseSettings/tabs/DataProcessingTab.d.ts

@@ -0,0 +1,24 @@
+import { CourseRaw } from '../../../store/useCourseStore';
+interface DataProcessingTabProps {
+    formData: CourseRaw;
+    setFormData: (data: CourseRaw) => void;
+}
+/**
+ * DataProcessingTab Component
+ *
+ * @version 3.0.0
+ * @breaking-changes
+ * - Updated component import paths to feature-based structure
+ * - Enhanced type safety for data processing options
+ * - Standardized string literals for legal bases
+ * - Improved default value handling
+ * - Added proper type definitions for processing settings
+ *
+ * Provides interface for:
+ * - Setting data processing legal basis
+ * - Managing special category data handling
+ * - Configuring retention periods
+ * - Setting data processing purposes
+ */
+export default function DataProcessingTab({ formData, setFormData, }: DataProcessingTabProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/LMSToolpad/components/Courses/Forms/CourseSettings/tabs/EnrollmentTab.d.ts

@@ -0,0 +1,28 @@
+import { CourseRaw } from '../../../store/useCourseStore';
+import { UserData } from '../../../../../components/Events/userTypes';
+interface EnrollmentTabProps {
+    formData: CourseRaw;
+    setFormData: (data: CourseRaw) => void;
+    courseUsers?: UserData[];
+}
+/**
+ * EnrollmentTab Component
+ *
+ * @version 3.0.0
+ * @breaking-changes
+ * - Enhanced TypeScript string literal types
+ * - Improved student list management with better state handling
+ * - Updated styling for better visual hierarchy
+ * - Enhanced date handling with proper typing
+ * - Improved responsive design for mobile and desktop views
+ * - Added proper type definitions for enrollment statuses
+ *
+ * Provides interface for:
+ * - Managing course enrollment settings
+ * - Handling student enrollment requests
+ * - Setting enrollment periods
+ * - Managing enrollment capacity
+ * - Viewing enrolled and pending students
+ */
+export default function EnrollmentTab({ formData, setFormData, courseUsers: _courseUsers, }: EnrollmentTabProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/LMSToolpad/components/Courses/Forms/CourseSettings/tabs/RelationshipsTab.d.ts

@@ -0,0 +1,25 @@
+import { CourseRaw } from '../../../store/useCourseStore';
+interface RelationshipsTabProps {
+    formData: CourseRaw;
+    setFormData: (data: CourseRaw) => void;
+}
+/**
+ * RelationshipsTab Component
+ *
+ * @version 3.0.0
+ * @breaking-changes
+ * - Updated course store import path to feature-based structure
+ * - Enhanced type definitions for course relationships
+ * - Standardized string literals for relationship types
+ * - Improved relationship type descriptions
+ * - Added better type safety for relationship management
+ *
+ * Provides interface for:
+ * - Managing course prerequisites
+ * - Setting up course continuations
+ * - Defining alternative courses
+ * - Managing course dependencies
+ * - Creating course relationship networks
+ */
+export default function RelationshipsTab({ formData, setFormData, }: RelationshipsTabProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/LMSToolpad/components/Courses/Forms/CourseSettings/tabs/StaffTab.d.ts

@@ -0,0 +1,26 @@
+import { CourseRaw } from '../../../store/useCourseStore';
+import { UserData } from '../../../../../components/Events/userTypes';
+interface StaffTabProps {
+    formData: CourseRaw;
+    setFormData: (data: CourseRaw) => void;
+    courseUsers?: UserData[];
+}
+/**
+ * StaffTab Component
+ *
+ * @version 3.0.0
+ * @breaking-changes
+ * - Updated course store import path to feature-based structure
+ * - Enhanced TypeScript type definitions for staff roles
+ * - Improved staff removal confirmation handling
+ * - Updated styling for better accessibility
+ * - Added proper aria labels for actions
+ *
+ * Provides interface for:
+ * - Managing course staff members
+ * - Adding/removing teaching staff
+ * - Viewing staff permissions
+ * - Managing staff roles
+ */
+export default function StaffTab({ formData, setFormData }: StaffTabProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/LMSToolpad/components/Courses/Forms/CourseSettings/tabs/VisibilityTab.d.ts

@@ -0,0 +1,24 @@
+import { CourseRaw } from '../../../store/useCourseStore';
+interface VisibilityTabProps {
+    formData: CourseRaw;
+    setFormData: (data: CourseRaw) => void;
+}
+/**
+ * VisibilityTab Component
+ *
+ * @version 3.0.0
+ * @breaking-changes
+ * - Standardized string literals for visibility modes
+ * - Enhanced type safety for visibility settings
+ * - Improved date picker integration
+ * - Added helper text explanations for each visibility mode
+ * - Updated styling for better visual feedback
+ *
+ * Provides interface for:
+ * - Setting course visibility mode
+ * - Configuring visibility periods
+ * - Managing access control
+ * - Setting visibility schedules
+ */
+export default function VisibilityTab({ formData, setFormData, }: VisibilityTabProps): import("react/jsx-runtime").JSX.Element;
+export {};

package/dist/src/LMSToolpad/components/Courses/Navigation/CourseNavigationbuilder.d.ts

@@ -0,0 +1,2 @@
+import { default as React } from 'react';
+export declare const CourseNavigationBuilder: React.FC;

package/dist/src/LMSToolpad/components/Courses/components/ToolDisplayer/ToolCard.d.ts

@@ -0,0 +1,8 @@
+import { NavigationPageStoreItem } from '@toolpad/core';
+type ToolCardProps = {
+    item: NavigationPageStoreItem;
+    onToggleService?: (path: string) => void;
+    isUsed?: boolean;
+};
+declare const ToolCard: ({ item, onToggleService, isUsed }: ToolCardProps) => import("react/jsx-runtime").JSX.Element;
+export default ToolCard;

package/dist/src/LMSToolpad/components/Courses/components/ToolDisplayer/ToolDisplayer.d.ts

@@ -0,0 +1,11 @@
+import { NavigationPageStoreItem } from '@toolpad/core';
+interface ToolDisplayerProps {
+    show: boolean;
+    title: string;
+    onToggleService?: (path: string) => void;
+    navItems: NavigationPageStoreItem[];
+    roleCheck?: boolean;
+    isUsed?: boolean;
+}
+declare const ToolDisplayer: ({ show, onToggleService, navItems, roleCheck, isUsed, }: ToolDisplayerProps) => import("react/jsx-runtime").JSX.Element;
+export default ToolDisplayer;

package/dist/src/LMSToolpad/components/Courses/config/subjectConfig.d.ts

@@ -0,0 +1,10 @@
+import { courseLevel } from '../store/useCourseStore';
+export declare const subjectConfig: {
+    [key: string]: {
+        icon: string;
+        baseColor: string;
+        levelShades: {
+            [K in courseLevel]: string;
+        };
+    };
+};

package/dist/src/LMSToolpad/components/Courses/context/CourseMicroserviceContext.d.ts

@@ -0,0 +1,26 @@
+import { default as React, ReactNode } from 'react';
+import { NavigationPageStoreItem } from '@toolpad/core';
+/**
+ * Context for course microservices to register themselves
+ */
+export interface CourseMicroserviceContextValue {
+    registerCourseMicroservice: (navigation: NavigationPageStoreItem) => void;
+    unregisterCourseMicroservice: (segment: string) => void;
+    allCourseMicroserviceNavigation: NavigationPageStoreItem[];
+    isInsideCourseMicroservice: boolean;
+}
+export declare const CourseMicroserviceContext: React.Context<CourseMicroserviceContextValue>;
+/**
+ * Hook for course microservices to register themselves.
+ * Returns isInsideCourseMicroservice=false if used outside CourseMicroservice provider.
+ */
+export declare const useCourseMicroserviceRegistration: () => CourseMicroserviceContextValue;
+interface CourseMicroserviceProviderProps {
+    children: ReactNode;
+}
+/**
+ * Provider component for CourseMicroserviceContext.
+ * Manages the state of registered course microservices and syncs with the navigation store.
+ */
+export declare const CourseMicroserviceProvider: React.FC<CourseMicroserviceProviderProps>;
+export {};

package/dist/src/LMSToolpad/components/Courses/hooks/useCourseRoutes.d.ts

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

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

@@ -0,0 +1,9 @@
+/** @format */
+export declare const subjectTopics: {
+    readonly 'COMP.CS': readonly ["Programming", "Data Structures", "Algorithms", "Web Development", "Machine Learning", "Artificial Intelligence", "Cybersecurity", "Computer Networks", "Operating Systems", "Software Engineering", "Database Systems", "Computer Graphics", "Mobile Development", "Cloud Computing"];
+    readonly MATH: readonly ["Calculus", "Linear Algebra", "Discrete Mathematics", "Statistics", "Probability Theory", "Number Theory", "Differential Equations", "Numerical Analysis", "Optimization", "Graph Theory"];
+    readonly PHYS: readonly ["Mechanics", "Thermodynamics", "Electromagnetism", "Quantum Physics", "Optics", "Nuclear Physics", "Relativity", "Particle Physics", "Astrophysics", "Material Science"];
+    readonly BIO: readonly ["Cell Biology", "Genetics", "Ecology", "Microbiology", "Molecular Biology", "Physiology", "Evolution", "Biochemistry", "Neuroscience", "Biotechnology"];
+    readonly CHEM: readonly ["Organic Chemistry", "Inorganic Chemistry", "Physical Chemistry", "Analytical Chemistry", "Biochemistry", "Polymer Chemistry", "Environmental Chemistry", "Medicinal Chemistry", "Material Chemistry", "Chemical Engineering"];
+    readonly LANG: readonly ["Academic Writing", "Technical Communication", "Scientific Writing", "Research Methods", "Professional Communication", "Intercultural Communication", "Digital Communication", "Documentation", "Content Design", "Public Speaking"];
+};

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

@@ -0,0 +1,8 @@
+import { HttpResponse } from 'msw';
+import { CourseBackendData, CourseRawBackendData } from './types';
+export declare const getCourseByIdResponse: (courseId: string) => HttpResponse;
+export declare const getCoursesResponse: () => HttpResponse;
+export declare const createCourseResponse: (newCourse: CourseRawBackendData) => HttpResponse;
+export declare const updateCourseResponse: (updatedCourse: CourseBackendData) => HttpResponse;
+export declare const deleteCourseResponse: (courseId: string) => HttpResponse;
+export declare const courseHandlers: import('msw').HttpHandler[];

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

@@ -0,0 +1,13 @@
+import { UserBackendData } from '../../Users/mocks/types';
+import { CourseBackendData, CourseEnrollmentBackendData } from './types';
+export declare function generateCourses(config: {
+    coursesPerYear: number;
+    startYear: number;
+    numberOfYears: number;
+    users: UserBackendData[];
+}): {
+    courses: CourseBackendData[];
+    enrollmentsByCourse: {
+        [key: string]: CourseEnrollmentBackendData[];
+    };
+};

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

@@ -0,0 +1,109 @@
+import { courseEventFrequency, courseLevel, courseRelationType, enrollmentStatus, legalBasis, visibilityMode, courseEventType, courseRole } from '../store/useCourseStore';
+export interface CourseEventBackendData {
+    id: string;
+    type: courseEventType;
+    title: string;
+    description?: string;
+    start_time: string;
+    end_time?: string;
+    location?: string;
+    teachers?: CourseEnrollmentBackendData[];
+    recurring?: {
+        frequency: courseEventFrequency;
+        until: string;
+        exceptions?: string[];
+    };
+    max_participants?: number;
+    requires_registration?: boolean;
+}
+export interface CourseEnrollmentBackendData {
+    user_id: string;
+    role: courseRole;
+    status: enrollmentStatus;
+    enrollment_date?: string;
+    request_date?: string;
+}
+export interface CourseRelationBackendData {
+    code: string;
+    type: courseRelationType;
+    description?: string;
+    required?: boolean;
+}
+export type CourseRawBackendData = {
+    title: string;
+    description: string;
+    code: string;
+    instance: string;
+    lti_login_url?: string;
+    services?: string[];
+    image?: {
+        large: string;
+        medium: string;
+        thumbnail: string;
+    };
+    start_date: string | null;
+    end_date: string | null;
+    visibility: {
+        mode: visibilityMode;
+        start_date: string | null;
+        end_date: string | null;
+    };
+    events: {
+        [key in courseEventType]: CourseEventBackendData[];
+    };
+    tags?: string[];
+    language?: string;
+    data_processing: {
+        purposes: string[];
+        retention: number;
+        third_party_processors: {
+            name: string;
+            purpose: string;
+            data_shared: string[];
+        }[];
+        special_categories: boolean;
+        legal_basis: legalBasis;
+    };
+    enrollment: {
+        start_date: string | null;
+        end_date: string | null;
+        status: {
+            open: boolean;
+            max_students?: number;
+        };
+    };
+    relationships?: {
+        prerequisites: CourseRelationBackendData[];
+        continuations: CourseRelationBackendData[];
+        alternatives: CourseRelationBackendData[];
+        related: CourseRelationBackendData[];
+    };
+    study_module?: {
+        name: string;
+        order?: number;
+        credits: number;
+        level: courseLevel;
+    };
+};
+export interface CourseBackendData extends CourseRawBackendData {
+    id: string;
+    created_at: string;
+    updated_at: string;
+}
+export interface CourseBackendDataWithEnrollments extends CourseBackendData {
+    data: {
+        my_data?: {
+            role: courseRole;
+            status: enrollmentStatus;
+        };
+        enrollment_data?: CourseEnrollmentBackendData[];
+    };
+}
+export interface CourseEnrollmentBackendData {
+    user_id: string;
+    course_id: string;
+    name: string;
+    email: string;
+    role: courseRole;
+    status: enrollmentStatus;
+}

package/dist/{LMSToolpad → src/LMSToolpad/components/Courses}/network/courses.d.ts

@@ -1,12 +1,5 @@
-/** @format */
 import { Course, CourseRaw } from '../store/useCourseStore';
 /**
- * @description Helper function to make a GET request to retrieve the current course
- * @returns Promise<Course> - The current course object
- */
-export declare function getCurrentCourse(): Promise<Course>;
-/**
- *
  * @description Helper function to make a GET request to retrieve courses
  * @returns Promise<Course[]> - The list of courses
  */
@@ -35,7 +28,7 @@ export declare function addCourse(courseData: CourseRaw): Promise<Course>;
  * @param courseData - The course data to update
  * @returns Updated course object
  */
-export declare function updateCourse(courseData: Course): Promise<Course>;
+export declare const updateCourse: (course: Course) => Promise<Course>;
 /**
  * @description Helper function to make a DELETE request to delete a course
  * @param courseId - The ID of the course to delete