@easyedu/js-lsm-api 1.83.0 → 1.85.0

package/src/apis/CourseApi.ts

@@ -53,11 +53,41 @@ import {
     GetCourseReportingBasicFromJSON,
     GetCourseReportingBasicToJSON,
 } from '../models/GetCourseReportingBasic';
+import {
+    type GetCourseVersion,
+    GetCourseVersionFromJSON,
+    GetCourseVersionToJSON,
+} from '../models/GetCourseVersion';
+import {
+    type GetCourseVersionItem,
+    GetCourseVersionItemFromJSON,
+    GetCourseVersionItemToJSON,
+} from '../models/GetCourseVersionItem';
+import {
+    type GetCourseVersionItemLaunch,
+    GetCourseVersionItemLaunchFromJSON,
+    GetCourseVersionItemLaunchToJSON,
+} from '../models/GetCourseVersionItemLaunch';
+import {
+    type GetCourseVersionItemSession,
+    GetCourseVersionItemSessionFromJSON,
+    GetCourseVersionItemSessionToJSON,
+} from '../models/GetCourseVersionItemSession';
+import {
+    type GetCourseVersionList,
+    GetCourseVersionListFromJSON,
+    GetCourseVersionListToJSON,
+} from '../models/GetCourseVersionList';
 import {
     type PostCourse,
     PostCourseFromJSON,
     PostCourseToJSON,
 } from '../models/PostCourse';
+import {
+    type PostCourseDraft,
+    PostCourseDraftFromJSON,
+    PostCourseDraftToJSON,
+} from '../models/PostCourseDraft';
 import {
     type PostCourseEnrollment,
     PostCourseEnrollmentFromJSON,
@@ -73,6 +103,21 @@ import {
     PostCourseResumeFromJSON,
     PostCourseResumeToJSON,
 } from '../models/PostCourseResume';
+import {
+    type PostCourseVersionItem,
+    PostCourseVersionItemFromJSON,
+    PostCourseVersionItemToJSON,
+} from '../models/PostCourseVersionItem';
+import {
+    type PostCourseVersionItemSession,
+    PostCourseVersionItemSessionFromJSON,
+    PostCourseVersionItemSessionToJSON,
+} from '../models/PostCourseVersionItemSession';
+import {
+    type PostCourseVersionPublish,
+    PostCourseVersionPublishFromJSON,
+    PostCourseVersionPublishToJSON,
+} from '../models/PostCourseVersionPublish';
 import {
     type PostDuplicate,
     PostDuplicateFromJSON,
@@ -88,6 +133,11 @@ import {
     PutCourseEnrollmentFromJSON,
     PutCourseEnrollmentToJSON,
 } from '../models/PutCourseEnrollment';
+import {
+    type PutCourseVersionItem,
+    PutCourseVersionItemFromJSON,
+    PutCourseVersionItemToJSON,
+} from '../models/PutCourseVersionItem';
 
 export interface DeleteCourseRequest {
     courseId: string;
@@ -107,6 +157,11 @@ export interface DeleteCourseImageRequest {
     courseId: string;
 }
 
+export interface DeleteCourseVersionItemRequest {
+    courseId: string;
+    itemId: string;
+}
+
 export interface DownloadCourseExportRequest {
     courseId: string;
     exportId: string;
@@ -116,6 +171,10 @@ export interface GetCourseRequest {
     courseId: string;
 }
 
+export interface GetCourseDraftRequest {
+    courseId: string;
+}
+
 export interface GetCourseEnrollmentRequest {
     courseId: string;
     enrollmentId: string;
@@ -153,10 +212,29 @@ export interface GetCourseReportingBasicRequest {
     courseId: string;
 }
 
+export interface GetCourseVersionItemLaunchRequest {
+    courseId: string;
+    courseVersionId: string;
+    itemId: string;
+}
+
+export interface GetCourseVersionListRequest {
+    courseId: string;
+}
+
 export interface PostCourseRequest {
     postCourse: PostCourse;
 }
 
+export interface PostCourseDraftRequest {
+    courseId: string;
+    postCourseDraft?: PostCourseDraft;
+}
+
+export interface PostCourseDraftResourceUpdateAllRequest {
+    courseId: string;
+}
+
 export interface PostCourseDuplicateRequest {
     courseId: string;
     postDuplicate?: PostDuplicate;
@@ -181,6 +259,24 @@ export interface PostCourseResumeRequest {
     courseId: string;
 }
 
+export interface PostCourseVersionItemRequest {
+    courseId: string;
+    postCourseVersionItem: PostCourseVersionItem;
+}
+
+export interface PostCourseVersionItemSessionRequest {
+    courseId: string;
+    courseVersionId: string;
+    itemId: string;
+    postCourseVersionItemSession?: PostCourseVersionItemSession;
+}
+
+export interface PostCourseVersionPublishRequest {
+    courseId: string;
+    courseVersionId: string;
+    postCourseVersionPublish?: PostCourseVersionPublish;
+}
+
 export interface PutCourseRequest {
     courseId: string;
     putCourse: Omit<PutCourse, 'id'>;
@@ -192,6 +288,12 @@ export interface PutCourseEnrollmentRequest {
     putCourseEnrollment: PutCourseEnrollment;
 }
 
+export interface PutCourseVersionItemRequest {
+    courseId: string;
+    itemId: string;
+    putCourseVersionItem: PutCourseVersionItem;
+}
+
 /**
  * 
  */
@@ -391,6 +493,58 @@ export class CourseApi extends runtime.BaseAPI {
         await this.deleteCourseImageRaw(requestParameters, initOverrides);
     }
 
+    /**
+     * Creates request options for deleteCourseVersionItem without sending the request
+     */
+    async deleteCourseVersionItemRequestOpts(requestParameters: DeleteCourseVersionItemRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['courseId'] == null) {
+            throw new runtime.RequiredError(
+                'courseId',
+                'Required parameter "courseId" was null or undefined when calling deleteCourseVersionItem().'
+            );
+        }
+
+        if (requestParameters['itemId'] == null) {
+            throw new runtime.RequiredError(
+                'itemId',
+                'Required parameter "itemId" was null or undefined when calling deleteCourseVersionItem().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/courses/{courseId}/draft/items/{itemId}`;
+        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+        urlPath = urlPath.replace('{itemId}', encodeURIComponent(String(requestParameters['itemId'])));
+
+        return {
+            path: urlPath,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Remove a placement from the course draft
+     */
+    async deleteCourseVersionItemRaw(requestParameters: DeleteCourseVersionItemRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        const requestOptions = await this.deleteCourseVersionItemRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Remove a placement from the course draft
+     */
+    async deleteCourseVersionItem(requestParameters: DeleteCourseVersionItemRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.deleteCourseVersionItemRaw(requestParameters, initOverrides);
+    }
+
     /**
      * Creates request options for downloadCourseExport without sending the request
      */
@@ -489,6 +643,51 @@ export class CourseApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for getCourseDraft without sending the request
+     */
+    async getCourseDraftRequestOpts(requestParameters: GetCourseDraftRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['courseId'] == null) {
+            throw new runtime.RequiredError(
+                'courseId',
+                'Required parameter "courseId" was null or undefined when calling getCourseDraft().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/courses/{courseId}/draft`;
+        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get the current course draft
+     */
+    async getCourseDraftRaw(requestParameters: GetCourseDraftRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCourseVersion>> {
+        const requestOptions = await this.getCourseDraftRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCourseVersionFromJSON(jsonValue));
+    }
+
+    /**
+     * Get the current course draft
+     */
+    async getCourseDraft(requestParameters: GetCourseDraftRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCourseVersion> {
+        const response = await this.getCourseDraftRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for getCourseEnrollment without sending the request
      */
@@ -815,6 +1014,112 @@ export class CourseApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for getCourseVersionItemLaunch without sending the request
+     */
+    async getCourseVersionItemLaunchRequestOpts(requestParameters: GetCourseVersionItemLaunchRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['courseId'] == null) {
+            throw new runtime.RequiredError(
+                'courseId',
+                'Required parameter "courseId" was null or undefined when calling getCourseVersionItemLaunch().'
+            );
+        }
+
+        if (requestParameters['courseVersionId'] == null) {
+            throw new runtime.RequiredError(
+                'courseVersionId',
+                'Required parameter "courseVersionId" was null or undefined when calling getCourseVersionItemLaunch().'
+            );
+        }
+
+        if (requestParameters['itemId'] == null) {
+            throw new runtime.RequiredError(
+                'itemId',
+                'Required parameter "itemId" was null or undefined when calling getCourseVersionItemLaunch().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/courses/{courseId}/versions/{courseVersionId}/items/{itemId}/launch`;
+        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+        urlPath = urlPath.replace('{courseVersionId}', encodeURIComponent(String(requestParameters['courseVersionId'])));
+        urlPath = urlPath.replace('{itemId}', encodeURIComponent(String(requestParameters['itemId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Resolve the exact immutable resource launch selected by a course version
+     */
+    async getCourseVersionItemLaunchRaw(requestParameters: GetCourseVersionItemLaunchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCourseVersionItemLaunch>> {
+        const requestOptions = await this.getCourseVersionItemLaunchRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCourseVersionItemLaunchFromJSON(jsonValue));
+    }
+
+    /**
+     * Resolve the exact immutable resource launch selected by a course version
+     */
+    async getCourseVersionItemLaunch(requestParameters: GetCourseVersionItemLaunchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCourseVersionItemLaunch> {
+        const response = await this.getCourseVersionItemLaunchRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getCourseVersionList without sending the request
+     */
+    async getCourseVersionListRequestOpts(requestParameters: GetCourseVersionListRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['courseId'] == null) {
+            throw new runtime.RequiredError(
+                'courseId',
+                'Required parameter "courseId" was null or undefined when calling getCourseVersionList().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/courses/{courseId}/versions`;
+        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * List immutable course versions and the current draft
+     */
+    async getCourseVersionListRaw(requestParameters: GetCourseVersionListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCourseVersionList>> {
+        const requestOptions = await this.getCourseVersionListRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCourseVersionListFromJSON(jsonValue));
+    }
+
+    /**
+     * List immutable course versions and the current draft
+     */
+    async getCourseVersionList(requestParameters: GetCourseVersionListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCourseVersionList> {
+        const response = await this.getCourseVersionListRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for postCourse without sending the request
      */
@@ -862,6 +1167,99 @@ export class CourseApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for postCourseDraft without sending the request
+     */
+    async postCourseDraftRequestOpts(requestParameters: PostCourseDraftRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['courseId'] == null) {
+            throw new runtime.RequiredError(
+                'courseId',
+                'Required parameter "courseId" was null or undefined when calling postCourseDraft().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/courses/{courseId}/draft`;
+        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostCourseDraftToJSON(requestParameters['postCourseDraft']),
+        };
+    }
+
+    /**
+     * Create or return the single editable course draft
+     */
+    async postCourseDraftRaw(requestParameters: PostCourseDraftRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCourseVersion>> {
+        const requestOptions = await this.postCourseDraftRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCourseVersionFromJSON(jsonValue));
+    }
+
+    /**
+     * Create or return the single editable course draft
+     */
+    async postCourseDraft(requestParameters: PostCourseDraftRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCourseVersion> {
+        const response = await this.postCourseDraftRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postCourseDraftResourceUpdateAll without sending the request
+     */
+    async postCourseDraftResourceUpdateAllRequestOpts(requestParameters: PostCourseDraftResourceUpdateAllRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['courseId'] == null) {
+            throw new runtime.RequiredError(
+                'courseId',
+                'Required parameter "courseId" was null or undefined when calling postCourseDraftResourceUpdateAll().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/courses/{courseId}/draft/resources/update-all`;
+        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Update all draft resource placements to their latest published versions
+     */
+    async postCourseDraftResourceUpdateAllRaw(requestParameters: PostCourseDraftResourceUpdateAllRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCourseVersion>> {
+        const requestOptions = await this.postCourseDraftResourceUpdateAllRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCourseVersionFromJSON(jsonValue));
+    }
+
+    /**
+     * Update all draft resource placements to their latest published versions
+     */
+    async postCourseDraftResourceUpdateAll(requestParameters: PostCourseDraftResourceUpdateAllRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCourseVersion> {
+        const response = await this.postCourseDraftResourceUpdateAllRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for postCourseDuplicate without sending the request
      */
@@ -1151,6 +1549,181 @@ export class CourseApi extends runtime.BaseAPI {
         }
     }
 
+    /**
+     * Creates request options for postCourseVersionItem without sending the request
+     */
+    async postCourseVersionItemRequestOpts(requestParameters: PostCourseVersionItemRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['courseId'] == null) {
+            throw new runtime.RequiredError(
+                'courseId',
+                'Required parameter "courseId" was null or undefined when calling postCourseVersionItem().'
+            );
+        }
+
+        if (requestParameters['postCourseVersionItem'] == null) {
+            throw new runtime.RequiredError(
+                'postCourseVersionItem',
+                'Required parameter "postCourseVersionItem" was null or undefined when calling postCourseVersionItem().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/courses/{courseId}/draft/items`;
+        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostCourseVersionItemToJSON(requestParameters['postCourseVersionItem']),
+        };
+    }
+
+    /**
+     * Add a specific Content Library version to the course draft
+     */
+    async postCourseVersionItemRaw(requestParameters: PostCourseVersionItemRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCourseVersionItem>> {
+        const requestOptions = await this.postCourseVersionItemRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCourseVersionItemFromJSON(jsonValue));
+    }
+
+    /**
+     * Add a specific Content Library version to the course draft
+     */
+    async postCourseVersionItem(requestParameters: PostCourseVersionItemRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCourseVersionItem> {
+        const response = await this.postCourseVersionItemRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postCourseVersionItemSession without sending the request
+     */
+    async postCourseVersionItemSessionRequestOpts(requestParameters: PostCourseVersionItemSessionRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['courseId'] == null) {
+            throw new runtime.RequiredError(
+                'courseId',
+                'Required parameter "courseId" was null or undefined when calling postCourseVersionItemSession().'
+            );
+        }
+
+        if (requestParameters['courseVersionId'] == null) {
+            throw new runtime.RequiredError(
+                'courseVersionId',
+                'Required parameter "courseVersionId" was null or undefined when calling postCourseVersionItemSession().'
+            );
+        }
+
+        if (requestParameters['itemId'] == null) {
+            throw new runtime.RequiredError(
+                'itemId',
+                'Required parameter "itemId" was null or undefined when calling postCourseVersionItemSession().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/courses/{courseId}/versions/{courseVersionId}/items/{itemId}/sessions`;
+        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+        urlPath = urlPath.replace('{courseVersionId}', encodeURIComponent(String(requestParameters['courseVersionId'])));
+        urlPath = urlPath.replace('{itemId}', encodeURIComponent(String(requestParameters['itemId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostCourseVersionItemSessionToJSON(requestParameters['postCourseVersionItemSession']),
+        };
+    }
+
+    /**
+     * Start or resume a version-pinned resource attempt
+     */
+    async postCourseVersionItemSessionRaw(requestParameters: PostCourseVersionItemSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCourseVersionItemSession>> {
+        const requestOptions = await this.postCourseVersionItemSessionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCourseVersionItemSessionFromJSON(jsonValue));
+    }
+
+    /**
+     * Start or resume a version-pinned resource attempt
+     */
+    async postCourseVersionItemSession(requestParameters: PostCourseVersionItemSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCourseVersionItemSession> {
+        const response = await this.postCourseVersionItemSessionRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postCourseVersionPublish without sending the request
+     */
+    async postCourseVersionPublishRequestOpts(requestParameters: PostCourseVersionPublishRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['courseId'] == null) {
+            throw new runtime.RequiredError(
+                'courseId',
+                'Required parameter "courseId" was null or undefined when calling postCourseVersionPublish().'
+            );
+        }
+
+        if (requestParameters['courseVersionId'] == null) {
+            throw new runtime.RequiredError(
+                'courseVersionId',
+                'Required parameter "courseVersionId" was null or undefined when calling postCourseVersionPublish().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/courses/{courseId}/versions/{courseVersionId}/publish`;
+        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+        urlPath = urlPath.replace('{courseVersionId}', encodeURIComponent(String(requestParameters['courseVersionId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostCourseVersionPublishToJSON(requestParameters['postCourseVersionPublish']),
+        };
+    }
+
+    /**
+     * Publish an immutable course version
+     */
+    async postCourseVersionPublishRaw(requestParameters: PostCourseVersionPublishRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCourseVersion>> {
+        const requestOptions = await this.postCourseVersionPublishRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCourseVersionFromJSON(jsonValue));
+    }
+
+    /**
+     * Publish an immutable course version
+     */
+    async postCourseVersionPublish(requestParameters: PostCourseVersionPublishRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCourseVersion> {
+        const response = await this.postCourseVersionPublishRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for putCourse without sending the request
      */
@@ -1269,6 +1842,69 @@ export class CourseApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for putCourseVersionItem without sending the request
+     */
+    async putCourseVersionItemRequestOpts(requestParameters: PutCourseVersionItemRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['courseId'] == null) {
+            throw new runtime.RequiredError(
+                'courseId',
+                'Required parameter "courseId" was null or undefined when calling putCourseVersionItem().'
+            );
+        }
+
+        if (requestParameters['itemId'] == null) {
+            throw new runtime.RequiredError(
+                'itemId',
+                'Required parameter "itemId" was null or undefined when calling putCourseVersionItem().'
+            );
+        }
+
+        if (requestParameters['putCourseVersionItem'] == null) {
+            throw new runtime.RequiredError(
+                'putCourseVersionItem',
+                'Required parameter "putCourseVersionItem" was null or undefined when calling putCourseVersionItem().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/courses/{courseId}/draft/items/{itemId}`;
+        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+        urlPath = urlPath.replace('{itemId}', encodeURIComponent(String(requestParameters['itemId'])));
+
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PutCourseVersionItemToJSON(requestParameters['putCourseVersionItem']),
+        };
+    }
+
+    /**
+     * Change draft placement settings or selected version
+     */
+    async putCourseVersionItemRaw(requestParameters: PutCourseVersionItemRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCourseVersionItem>> {
+        const requestOptions = await this.putCourseVersionItemRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCourseVersionItemFromJSON(jsonValue));
+    }
+
+    /**
+     * Change draft placement settings or selected version
+     */
+    async putCourseVersionItem(requestParameters: PutCourseVersionItemRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCourseVersionItem> {
+        const response = await this.putCourseVersionItemRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
 }
 
 /**