@lumina-study/courses-sdk
Version:
Type-safe TypeScript SDK for the Courses Platform API, auto-generated from OpenAPI specification
1,599 lines (1,595 loc) • 66.7 kB
text/typescript
import { Client } from 'openapi-fetch';
/**
* SDK configuration interface
*/
interface SDKConfig {
/**
* Base URL for the API (e.g., "https://api.example.com")
*/
baseUrl: string;
/**
* Optional callback to retrieve authentication token.
* Called on every request to get fresh token.
* Can return string (token), null (no auth), or Promise for async retrieval.
*/
getToken?: () => string | null | Promise<string | null>;
/**
* Optional custom fetch implementation for testing
*/
fetch?: typeof fetch;
}
/**
* This file was auto-generated by openapi-typescript.
* Do not make direct changes to the file.
*/
interface paths {
"/api/courses": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
/**
* Get all published courses
* @description Retrieve all published courses. This is a public endpoint that does not require authentication.
*
* **Behavior:**
* - Returns only courses with at least one published version
* - Each course includes its latest published version in the `latestVersion` field
* - Unpublished drafts are excluded from results
* - Owned by any user (ownerId is visible in response)
*
* **Use Cases:**
* - Display course catalog to unauthenticated visitors
* - Browse available courses before signing up
* - Public course discovery and search
*
* **Example Response:**
* ```json
* [
* {
* "id": "course-uuid-123",
* "ownerId": "user-uuid-456",
* "categories": ["Computer Science"],
* "tags": ["beginner"],
* "createdAt": "2025-01-30T10:00:00Z",
* "updatedAt": "2025-01-30T10:00:00Z",
* "latestVersion": {
* "id": "version-uuid-789",
* "versionNumber": 1,
* "data": {
* "name": "Introduction to CS",
* "institution": "MIT"
* },
* "isPublished": true,
* "publishedAt": "2025-01-30T10:00:00Z"
* }
* }
* ]
* ```
*/
get: operations["CoursesController_findAll"];
put?: never;
/**
* Create course (admin only - legacy endpoint)
* @description Admin-only endpoint for direct course creation. Regular users should use POST /courses/publish instead.
*/
post: operations["CoursesController_create"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/courses/publish": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/**
* Publish a new course from local draft
* @description Publish a course created locally in the browser. This is the recommended method for course creation.
*
* **Local-First Workflow:**
* - Users create and edit courses in their browser (IndexedDB) without requiring authentication
* - When ready to publish, users authenticate and submit the complete course data
* - The server assigns ownership (ownerId) to the authenticated user
* - After successful publish, the client removes the local draft
*
* **Example Request Body:**
* ```json
* {
* "data": {
* "name": "Introduction to Computer Science",
* "institution": "MIT",
* "instructor": "Prof. John Doe",
* "description": "Learn fundamental CS concepts"
* },
* "categories": ["Computer Science", "Programming"],
* "tags": ["beginner", "algorithms"]
* }
* ```
*
* **Example Response:**
* ```json
* {
* "id": "course-uuid-123",
* "ownerId": "user-uuid-456",
* "categories": ["Computer Science", "Programming"],
* "tags": ["beginner", "algorithms"],
* "createdAt": "2025-01-30T10:00:00Z",
* "updatedAt": "2025-01-30T10:00:00Z",
* "latestVersion": {
* "id": "version-uuid-789",
* "courseId": "course-uuid-123",
* "versionNumber": 1,
* "data": {
* "name": "Introduction to Computer Science",
* "institution": "MIT",
* "instructor": "Prof. John Doe",
* "description": "Learn fundamental CS concepts"
* },
* "isPublished": true,
* "publishedAt": "2025-01-30T10:00:00Z",
* "createdById": "user-uuid-456",
* "createdAt": "2025-01-30T10:00:00Z"
* }
* }
* ```
*/
post: operations["CoursesController_publishCourse"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/courses/my-courses": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
/**
* Get my owned courses
* @description Retrieve all courses owned by the authenticated user, including both published and unpublished drafts.
*
* **Behavior:**
* - Returns only courses where `ownerId` matches the authenticated user's ID
* - Includes both published courses and unpublished drafts
* - Sorted by `updatedAt` descending (most recently updated first)
* - Each course includes its latest version (published or unpublished)
*
* **Use Cases:**
* - Display user's course dashboard
* - List courses for editing or management
* - Show publishing status for each owned course
*
* **Authentication:** JWT token required in Authorization header
*
* **Example Response:**
* ```json
* [
* {
* "id": "course-uuid-123",
* "ownerId": "user-uuid-456",
* "categories": ["Math"],
* "tags": ["advanced"],
* "createdAt": "2025-01-29T10:00:00Z",
* "updatedAt": "2025-01-30T15:00:00Z",
* "latestVersion": {
* "id": "version-uuid-789",
* "versionNumber": 2,
* "data": {
* "name": "Advanced Calculus",
* "institution": "MIT"
* },
* "isPublished": true,
* "publishedAt": "2025-01-30T15:00:00Z"
* }
* },
* {
* "id": "course-uuid-999",
* "ownerId": "user-uuid-456",
* "categories": ["Physics"],
* "tags": [],
* "createdAt": "2025-01-28T10:00:00Z",
* "updatedAt": "2025-01-28T11:00:00Z",
* "latestVersion": {
* "id": "version-uuid-888",
* "versionNumber": 1,
* "data": {
* "name": "Quantum Mechanics Draft",
* "institution": "Stanford"
* },
* "isPublished": false,
* "publishedAt": null
* }
* }
* ]
* ```
*/
get: operations["CoursesController_findMyCourses"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/courses/search": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get: operations["CoursesController_search"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/courses/published": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get: operations["CoursesController_findAllPublished"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/courses/{id}": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get: operations["CoursesController_findOne"];
put?: never;
post?: never;
delete: operations["CoursesController_remove"];
options?: never;
head?: never;
patch: operations["CoursesController_update"];
trace?: never;
};
"/api/courses/{id}/publish": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch: operations["CoursesController_publish"];
trace?: never;
};
"/api/courses/{id}/unpublish": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch: operations["CoursesController_unpublish"];
trace?: never;
};
"/api/courses/{id}/versions": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
/** Get version history for a course */
get: operations["CoursesController_getVersionHistory"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/courses/{id}/versions/latest": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
/** Get the latest version of a course */
get: operations["CoursesController_getLatestVersion"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/courses/{id}/versions/compare": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
/** Compare two versions of a course */
get: operations["CoursesController_compareVersions"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/courses/{id}/versions/{versionNumber}": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
/** Get a specific version of a course */
get: operations["CoursesController_getVersion"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/courses/{id}/copy": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
/**
* Copy a course for editing
* @description Create an editable copy of a published course. The copy is owned by the authenticated user and starts as unpublished.
*
* **Use Cases:**
* - Users want to customize an existing course for their needs
* - Teachers want to use a course as a template
* - Students want to create their own version of a course
*
* **Behavior:**
* - Only published courses can be copied
* - Copy starts with version 1 in unpublished state
* - Complete course structure is deep copied (metadata, modules, connections)
* - Copy is fully independent - changes don't affect original
* - Copy owner is set to authenticated user
*
* **Example Response:**
* ```json
* {
* "id": "new-course-uuid-789",
* "ownerId": "user-uuid-456",
* "categories": ["Computer Science"],
* "tags": ["beginner"],
* "createdAt": "2025-11-03T00:30:00Z",
* "updatedAt": "2025-11-03T00:30:00Z",
* "latestVersion": {
* "id": "version-uuid-001",
* "courseId": "new-course-uuid-789",
* "versionNumber": 1,
* "data": {
* "name": "Introduction to CS (Copy)",
* "institution": "MIT",
* "modules": { /* complete module structure *\/ }
* },
* "isPublished": false,
* "publishedAt": null,
* "createdById": "user-uuid-456",
* "createdAt": "2025-11-03T00:30:00Z"
* }
* }
* ```
*/
post: operations["CoursesController_copyCourse"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/admin/courses": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get: operations["AdminCoursesController_findAll"];
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/admin/courses/{id}": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get: operations["AdminCoursesController_findOne"];
put?: never;
post?: never;
delete: operations["AdminCoursesController_remove"];
options?: never;
head?: never;
patch: operations["AdminCoursesController_update"];
trace?: never;
};
"/api/admin/courses/{id}/publish": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch: operations["AdminCoursesController_publish"];
trace?: never;
};
"/api/admin/courses/{id}/unpublish": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
get?: never;
put?: never;
post?: never;
delete?: never;
options?: never;
head?: never;
patch: operations["AdminCoursesController_unpublish"];
trace?: never;
};
"/api/enrollments": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
/**
* Get all enrollments for authenticated user
* @description Retrieve all active enrollments for the authenticated user.
*
* **Authentication:** Required - JWT token in Authorization header
*
* **Behavior:**
* - Returns only enrollments where userId matches authenticated user
* - Filters by status = 'active' (excludes withdrawn enrollments)
* - Returns empty array if user has no active enrollments
*
* **Example Response:**
* ```json
* [
* {
* "id": "enrollment-1",
* "userId": "user-123",
* "courseId": "course-1",
* "status": "active",
* "enrolledAt": "2025-01-29T10:00:00Z",
* "withdrawnAt": null,
* "createdAt": "2025-01-29T10:00:00Z",
* "updatedAt": "2025-01-29T10:00:00Z"
* },
* {
* "id": "enrollment-2",
* "userId": "user-123",
* "courseId": "course-2",
* "status": "active",
* "enrolledAt": "2025-01-30T10:00:00Z",
* "withdrawnAt": null,
* "createdAt": "2025-01-30T10:00:00Z",
* "updatedAt": "2025-01-30T10:00:00Z"
* }
* ]
* ```
*/
get: operations["EnrollmentsController_getUserEnrollments"];
put?: never;
/**
* Enroll in a course
* @description Enroll the authenticated user in a course. If the user is already enrolled, returns the existing enrollment (idempotent operation).
*
* **Authentication:** Required - JWT token in Authorization header
*
* **Behavior:**
* - Validates that the course exists
* - Checks if user is already enrolled
* - Returns existing enrollment if found (no error)
* - Creates new enrollment if not found
* - Sets status to 'active' and enrolledAt to current timestamp
*
* **Example Request Body:**
* ```json
* {
* "courseId": "123e4567-e89b-12d3-a456-426614174000"
* }
* ```
*
* **Example Response:**
* ```json
* {
* "id": "enrollment-uuid",
* "userId": "user-123",
* "courseId": "123e4567-e89b-12d3-a456-426614174000",
* "status": "active",
* "enrolledAt": "2025-01-30T10:00:00Z",
* "withdrawnAt": null,
* "createdAt": "2025-01-30T10:00:00Z",
* "updatedAt": "2025-01-30T10:00:00Z"
* }
* ```
*/
post: operations["EnrollmentsController_enroll"];
delete?: never;
options?: never;
head?: never;
patch?: never;
trace?: never;
};
"/api/enrollments/{courseId}": {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
/**
* Check enrollment status for a specific course
* @description Check if the authenticated user is enrolled in a specific course.
*
* **Authentication:** Required - JWT token in Authorization header
*
* **Behavior:**
* - Returns enrollment details if user is actively enrolled
* - Returns 404 if user is not enrolled or enrollment is withdrawn
*
* **Example Response:**
* ```json
* {
* "id": "enrollment-123",
* "userId": "user-123",
* "courseId": "123e4567-e89b-12d3-a456-426614174000",
* "status": "active",
* "enrolledAt": "2025-01-30T10:00:00Z",
* "withdrawnAt": null,
* "createdAt": "2025-01-30T10:00:00Z",
* "updatedAt": "2025-01-30T10:00:00Z"
* }
* ```
*/
get: operations["EnrollmentsController_getEnrollment"];
put?: never;
post?: never;
/**
* Withdraw from a course
* @description Mark enrollment as withdrawn for the authenticated user.
*
* **Authentication:** Required - JWT token in Authorization header
*
* **Behavior:**
* - Finds active enrollment for user and course
* - Updates status to 'withdrawn'
* - Sets withdrawnAt timestamp to current time
* - Returns 404 if no active enrollment exists
*
* **Example Response:**
* ```json
* {
* "id": "enrollment-123",
* "userId": "user-123",
* "courseId": "123e4567-e89b-12d3-a456-426614174000",
* "status": "withdrawn",
* "enrolledAt": "2025-01-30T10:00:00Z",
* "withdrawnAt": "2025-01-30T15:00:00Z",
* "createdAt": "2025-01-30T10:00:00Z",
* "updatedAt": "2025-01-30T15:00:00Z"
* }
* ```
*/
delete: operations["EnrollmentsController_withdraw"];
options?: never;
head?: never;
patch?: never;
trace?: never;
};
}
interface components {
schemas: {
ModuleNode: {
/**
* @description Unique identifier for the module node
* @example 1
*/
id: string;
/**
* @description Display label for the module
* @example Introduction to Algorithms
*/
label: string;
/**
* @description Sequential order number (null if unordered)
* @example 1
*/
order?: Record<string, never> | null;
/**
* @description Array of prerequisite module IDs
* @example [
* "0"
* ]
*/
pre: string[];
/**
* @description Array of dependent module IDs
* @example [
* "2",
* "3"
* ]
*/
post: string[];
};
ModuleGraph: {
/** @description Array of module nodes in the graph */
nodes: components["schemas"]["ModuleNode"][];
};
CourseData: {
/**
* @description The name of the course
* @example Introduction to Computer Science
*/
name: string;
/**
* @description The institution offering the course
* @example MIT
*/
institution?: string;
/** @description Course modules graph structure */
modules?: components["schemas"]["ModuleGraph"];
/**
* @description Categories the course belongs to
* @example [
* "Computer Science",
* "Mathematics"
* ]
*/
categories?: string[];
/**
* @description Tags for searchability and filtering
* @example [
* "algorithms",
* "beginner",
* "data-structures"
* ]
*/
tags?: string[];
};
CreateCourseDto: {
/**
* @description The course data containing name, institution, and other course details
* @example {
* "name": "Introduction to Computer Science",
* "institution": "MIT"
* }
*/
data: components["schemas"]["CourseData"];
/**
* @description Categories the course belongs to
* @example [
* "Computer Science",
* "Mathematics"
* ]
*/
categories?: string[];
/**
* @description Tags for searchability and filtering
* @example [
* "algorithms",
* "beginner",
* "data-structures"
* ]
*/
tags?: string[];
/**
* @description ID of the user who owns/created this course
* @example user-123
*/
ownerId?: string;
};
PublishCourseDto: {
/**
* @description The course data containing name, institution, and other course details
* @example {
* "name": "Introduction to Computer Science",
* "institution": "MIT"
* }
*/
data: components["schemas"]["CourseData"];
/**
* @description Categories the course belongs to
* @example [
* "Computer Science",
* "Mathematics"
* ]
*/
categories?: string[];
/**
* @description Tags for searchability and filtering
* @example [
* "algorithms",
* "beginner",
* "data-structures"
* ]
*/
tags?: string[];
};
UpdateCourseDto: {
/**
* @description The course data to update (partial updates supported)
* @example {
* "name": "Advanced Computer Science",
* "institution": "Stanford"
* }
*/
data?: components["schemas"]["CourseData"];
/**
* @description Categories the course belongs to
* @example [
* "Computer Science",
* "Mathematics"
* ]
*/
categories?: string[];
/**
* @description Tags for searchability and filtering
* @example [
* "algorithms",
* "beginner",
* "data-structures"
* ]
*/
tags?: string[];
/**
* @description ID of the user who owns/created this course
* @example user-123
*/
ownerId?: string;
};
CourseVersionMetadataDto: {
/**
* @description The sequential version number
* @example 1
*/
versionNumber: number;
/**
* @description Whether this version is published
* @example true
*/
isPublished: boolean;
/**
* @description Timestamp when the version was published (null if not published)
* @example 2025-10-19T10:00:00.000Z
*/
publishedAt: Record<string, never> | null;
/**
* @description ID of the user who created this version
* @example user-uuid-123
*/
createdById: string;
/**
* @description Timestamp when the version was created
* @example 2025-10-19T10:00:00.000Z
*/
createdAt: string;
};
VersionHistoryPaginationDto: {
/**
* @description Current page number
* @example 1
*/
page: number;
/**
* @description Number of versions per page
* @example 10
*/
pageSize: number;
/**
* @description Total number of versions
* @example 25
*/
totalVersions: number;
/**
* @description Total number of pages
* @example 3
*/
totalPages: number;
};
PaginatedVersionHistoryDto: {
/** @description Array of version metadata */
versions: components["schemas"]["CourseVersionMetadataDto"][];
/** @description Pagination information */
pagination: components["schemas"]["VersionHistoryPaginationDto"];
/**
* @description The latest version number for this course
* @example 3
*/
latestVersion: number;
};
CourseVersionDto: {
/**
* @description The unique identifier of the version
* @example uuid-123-456
*/
id: string;
/**
* @description The course ID this version belongs to
* @example course-uuid-123
*/
courseId: string;
/**
* @description The sequential version number
* @example 1
*/
versionNumber: number;
/**
* @description The complete course data for this version
* @example {
* "institution": "MIT",
* "title": "Introduction to Computer Science"
* }
*/
data: components["schemas"]["CourseData"];
/**
* @description Whether this version is published
* @example true
*/
isPublished: boolean;
/**
* @description Timestamp when the version was published (null if not published)
* @example 2025-10-19T10:00:00.000Z
*/
publishedAt: Record<string, never> | null;
/**
* @description ID of the user who created this version
* @example user-uuid-123
*/
createdById: string;
/**
* @description Timestamp when the version was created
* @example 2025-10-19T10:00:00.000Z
*/
createdAt: string;
};
VersionComparisonDto: {
/** @description The first version for comparison */
version1: components["schemas"]["CourseVersionDto"];
/** @description The second version for comparison */
version2: components["schemas"]["CourseVersionDto"];
};
CreateEnrollmentDto: {
/**
* Format: uuid
* @description The ID of the course to enroll in
* @example 123e4567-e89b-12d3-a456-426614174000
*/
courseId: string;
};
EnrollmentResponseDto: {
/**
* @description Unique identifier for the enrollment
* @example 123e4567-e89b-12d3-a456-426614174000
*/
id: string;
/**
* @description ID of the enrolled user
* @example user-123
*/
userId: string;
/**
* @description ID of the course
* @example 123e4567-e89b-12d3-a456-426614174000
*/
courseId: string;
/**
* @description Enrollment status
* @example active
* @enum {string}
*/
status: "active" | "withdrawn";
/**
* Format: date-time
* @description Timestamp when user enrolled
* @example 2025-01-30T10:00:00Z
*/
enrolledAt: string;
/**
* @description Timestamp when user withdrew (null if still active)
* @example null
*/
withdrawnAt: Record<string, never> | null;
/**
* Format: date-time
* @description Timestamp when enrollment was created
* @example 2025-01-30T10:00:00Z
*/
createdAt: string;
/**
* Format: date-time
* @description Timestamp when enrollment was last updated
* @example 2025-01-30T10:00:00Z
*/
updatedAt: string;
};
};
responses: never;
parameters: never;
requestBodies: never;
headers: never;
pathItems: never;
}
interface operations {
CoursesController_findAll: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody?: never;
responses: {
/** @description Array of published courses */
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_create: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["CreateCourseDto"];
};
};
responses: {
/** @description Course created successfully */
201: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Unauthorized - authentication required */
401: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Forbidden - admin access required */
403: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_publishCourse: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["PublishCourseDto"];
};
};
responses: {
/** @description Course published successfully with assigned ID and version 1 */
201: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/**
* @description Bad Request - validation errors in course data
*
* **Common validation errors:**
* - Missing required field: `data.name`
* - Empty course name (after trimming whitespace)
* - Invalid data types (e.g., name is not a string)
* - Invalid array format for categories or tags
*
* **Example error response:**
* ```json
* {
* "statusCode": 400,
* "message": [
* "data.name should not be empty",
* "data.name must be a string"
* ],
* "error": "Bad Request"
* }
* ```
*/
400: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/**
* @description Unauthorized - authentication required
*
* User must be authenticated with a valid JWT token to publish courses.
*
* **Example error response:**
* ```json
* {
* "statusCode": 401,
* "message": "Unauthorized"
* }
* ```
*/
401: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_findMyCourses: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody?: never;
responses: {
/** @description Array of owned courses (published and unpublished) */
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Unauthorized - authentication required */
401: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_search: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody?: never;
responses: {
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_findAllPublished: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody?: never;
responses: {
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_findOne: {
parameters: {
query?: never;
header?: never;
path: {
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_remove: {
parameters: {
query?: never;
header?: never;
path: {
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
204: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_update: {
parameters: {
query?: never;
header?: never;
path: {
id: string;
};
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["UpdateCourseDto"];
};
};
responses: {
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_publish: {
parameters: {
query?: never;
header?: never;
path: {
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_unpublish: {
parameters: {
query?: never;
header?: never;
path: {
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_getVersionHistory: {
parameters: {
query?: {
/** @description Page number (default: 1) */
page?: number;
/** @description Number of versions per page (default: 10, max: 100) */
pageSize?: number;
};
header?: never;
path: {
/** @description Course ID */
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description Paginated version history */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["PaginatedVersionHistoryDto"];
};
};
/** @description Invalid pagination parameters */
400: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Course not found */
404: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_getLatestVersion: {
parameters: {
query?: never;
header?: never;
path: {
/** @description Course ID */
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description Latest version data */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["CourseVersionDto"];
};
};
/** @description Access denied - version is not published and user is not owner/admin */
403: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Course not found or no versions exist */
404: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_compareVersions: {
parameters: {
query: {
/** @description First version number */
v1: number;
/** @description Second version number */
v2: number;
};
header?: never;
path: {
/** @description Course ID */
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description Comparison of two versions */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["VersionComparisonDto"];
};
};
/** @description Invalid version numbers */
400: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Access denied - one or both versions are not published and user is not owner/admin */
403: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description One or both versions not found */
404: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_getVersion: {
parameters: {
query?: never;
header?: never;
path: {
/** @description Course ID */
id: string;
/** @description Version number */
versionNumber: number;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description Version data */
200: {
headers: {
[name: string]: unknown;
};
content: {
"application/json": components["schemas"]["CourseVersionDto"];
};
};
/** @description Access denied - version is not published and user is not owner/admin */
403: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Version not found */
404: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
CoursesController_copyCourse: {
parameters: {
query?: never;
header?: never;
path: {
/** @description Source course ID (UUID format) */
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
/** @description Course copied successfully with new UUID and ownership */
201: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Bad Request - invalid course ID format */
400: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Unauthorized - authentication required to copy courses */
401: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Forbidden - cannot copy unpublished course */
403: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Not Found - source course does not exist */
404: {
headers: {
[name: string]: unknown;
};
content?: never;
};
/** @description Internal Server Error - failed to copy course */
500: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
AdminCoursesController_findAll: {
parameters: {
query?: never;
header?: never;
path?: never;
cookie?: never;
};
requestBody?: never;
responses: {
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
AdminCoursesController_findOne: {
parameters: {
query?: never;
header?: never;
path: {
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
AdminCoursesController_remove: {
parameters: {
query?: never;
header?: never;
path: {
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
204: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
AdminCoursesController_update: {
parameters: {
query?: never;
header?: never;
path: {
id: string;
};
cookie?: never;
};
requestBody: {
content: {
"application/json": components["schemas"]["UpdateCourseDto"];
};
};
responses: {
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
AdminCoursesController_publish: {
parameters: {
query?: never;
header?: never;
path: {
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
200: {
headers: {
[name: string]: unknown;
};
content?: never;
};
};
};
AdminCoursesController_unpublish: {
parameters: {
query?: never;
header?: never;
path: {
id: string;
};
cookie?: never;
};
requestBody?: never;
responses: {
200: {