@easyedu/js-lsm-api 1.83.0 → 1.84.0

package/dist/apis/CourseApi.js

@@ -32,13 +32,23 @@ const GetCourseExportList_1 = require("../models/GetCourseExportList");
 const GetCourseImageUpload_1 = require("../models/GetCourseImageUpload");
 const GetCourseList_1 = require("../models/GetCourseList");
 const GetCourseReportingBasic_1 = require("../models/GetCourseReportingBasic");
+const GetCourseVersion_1 = require("../models/GetCourseVersion");
+const GetCourseVersionItem_1 = require("../models/GetCourseVersionItem");
+const GetCourseVersionItemLaunch_1 = require("../models/GetCourseVersionItemLaunch");
+const GetCourseVersionItemSession_1 = require("../models/GetCourseVersionItemSession");
+const GetCourseVersionList_1 = require("../models/GetCourseVersionList");
 const PostCourse_1 = require("../models/PostCourse");
+const PostCourseDraft_1 = require("../models/PostCourseDraft");
 const PostCourseEnrollment_1 = require("../models/PostCourseEnrollment");
 const PostCourseExport_1 = require("../models/PostCourseExport");
 const PostCourseResume_1 = require("../models/PostCourseResume");
+const PostCourseVersionItem_1 = require("../models/PostCourseVersionItem");
+const PostCourseVersionItemSession_1 = require("../models/PostCourseVersionItemSession");
+const PostCourseVersionPublish_1 = require("../models/PostCourseVersionPublish");
 const PostDuplicate_1 = require("../models/PostDuplicate");
 const PutCourse_1 = require("../models/PutCourse");
 const PutCourseEnrollment_1 = require("../models/PutCourseEnrollment");
+const PutCourseVersionItem_1 = require("../models/PutCourseVersionItem");
 /**
  *
  */
@@ -205,6 +215,48 @@ class CourseApi extends runtime.BaseAPI {
             yield this.deleteCourseImageRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Creates request options for deleteCourseVersionItem without sending the request
+     */
+    deleteCourseVersionItemRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = {};
+            const headerParameters = {};
+            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
+     */
+    deleteCourseVersionItemRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.deleteCourseVersionItemRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Remove a placement from the course draft
+     */
+    deleteCourseVersionItem(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.deleteCourseVersionItemRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Creates request options for downloadCourseExport without sending the request
      */
@@ -287,6 +339,45 @@ class CourseApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for getCourseDraft without sending the request
+     */
+    getCourseDraftRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['courseId'] == null) {
+                throw new runtime.RequiredError('courseId', 'Required parameter "courseId" was null or undefined when calling getCourseDraft().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            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
+     */
+    getCourseDraftRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getCourseDraftRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, GetCourseVersion_1.GetCourseVersionFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Get the current course draft
+     */
+    getCourseDraft(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getCourseDraftRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for getCourseEnrollment without sending the request
      */
@@ -561,6 +652,92 @@ class CourseApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for getCourseVersionItemLaunch without sending the request
+     */
+    getCourseVersionItemLaunchRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = {};
+            const headerParameters = {};
+            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
+     */
+    getCourseVersionItemLaunchRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getCourseVersionItemLaunchRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, GetCourseVersionItemLaunch_1.GetCourseVersionItemLaunchFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Resolve the exact immutable resource launch selected by a course version
+     */
+    getCourseVersionItemLaunch(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getCourseVersionItemLaunchRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getCourseVersionList without sending the request
+     */
+    getCourseVersionListRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['courseId'] == null) {
+                throw new runtime.RequiredError('courseId', 'Required parameter "courseId" was null or undefined when calling getCourseVersionList().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            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
+     */
+    getCourseVersionListRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getCourseVersionListRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, GetCourseVersionList_1.GetCourseVersionListFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * List immutable course versions and the current draft
+     */
+    getCourseVersionList(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getCourseVersionListRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for postCourse without sending the request
      */
@@ -601,6 +778,86 @@ class CourseApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for postCourseDraft without sending the request
+     */
+    postCourseDraftRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['courseId'] == null) {
+                throw new runtime.RequiredError('courseId', 'Required parameter "courseId" was null or undefined when calling postCourseDraft().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            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: (0, PostCourseDraft_1.PostCourseDraftToJSON)(requestParameters['postCourseDraft']),
+            };
+        });
+    }
+    /**
+     * Create or return the single editable course draft
+     */
+    postCourseDraftRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCourseDraftRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, GetCourseVersion_1.GetCourseVersionFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Create or return the single editable course draft
+     */
+    postCourseDraft(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCourseDraftRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCourseDraftResourceUpdateAll without sending the request
+     */
+    postCourseDraftResourceUpdateAllRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['courseId'] == null) {
+                throw new runtime.RequiredError('courseId', 'Required parameter "courseId" was null or undefined when calling postCourseDraftResourceUpdateAll().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            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
+     */
+    postCourseDraftResourceUpdateAllRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCourseDraftResourceUpdateAllRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, GetCourseVersion_1.GetCourseVersionFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Update all draft resource placements to their latest published versions
+     */
+    postCourseDraftResourceUpdateAll(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCourseDraftResourceUpdateAllRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for postCourseDuplicate without sending the request
      */
@@ -843,6 +1100,144 @@ class CourseApi extends runtime.BaseAPI {
             }
         });
     }
+    /**
+     * Creates request options for postCourseVersionItem without sending the request
+     */
+    postCourseVersionItemRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = {};
+            const headerParameters = {};
+            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: (0, PostCourseVersionItem_1.PostCourseVersionItemToJSON)(requestParameters['postCourseVersionItem']),
+            };
+        });
+    }
+    /**
+     * Add a specific Content Library version to the course draft
+     */
+    postCourseVersionItemRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCourseVersionItemRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, GetCourseVersionItem_1.GetCourseVersionItemFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Add a specific Content Library version to the course draft
+     */
+    postCourseVersionItem(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCourseVersionItemRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCourseVersionItemSession without sending the request
+     */
+    postCourseVersionItemSessionRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = {};
+            const headerParameters = {};
+            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: (0, PostCourseVersionItemSession_1.PostCourseVersionItemSessionToJSON)(requestParameters['postCourseVersionItemSession']),
+            };
+        });
+    }
+    /**
+     * Start or resume a version-pinned resource attempt
+     */
+    postCourseVersionItemSessionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCourseVersionItemSessionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, GetCourseVersionItemSession_1.GetCourseVersionItemSessionFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Start or resume a version-pinned resource attempt
+     */
+    postCourseVersionItemSession(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCourseVersionItemSessionRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCourseVersionPublish without sending the request
+     */
+    postCourseVersionPublishRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = {};
+            const headerParameters = {};
+            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: (0, PostCourseVersionPublish_1.PostCourseVersionPublishToJSON)(requestParameters['postCourseVersionPublish']),
+            };
+        });
+    }
+    /**
+     * Publish an immutable course version
+     */
+    postCourseVersionPublishRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCourseVersionPublishRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, GetCourseVersion_1.GetCourseVersionFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Publish an immutable course version
+     */
+    postCourseVersionPublish(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCourseVersionPublishRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for putCourse without sending the request
      */
@@ -935,6 +1330,54 @@ class CourseApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for putCourseVersionItem without sending the request
+     */
+    putCourseVersionItemRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            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 = {};
+            const headerParameters = {};
+            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: (0, PutCourseVersionItem_1.PutCourseVersionItemToJSON)(requestParameters['putCourseVersionItem']),
+            };
+        });
+    }
+    /**
+     * Change draft placement settings or selected version
+     */
+    putCourseVersionItemRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.putCourseVersionItemRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, GetCourseVersionItem_1.GetCourseVersionItemFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Change draft placement settings or selected version
+     */
+    putCourseVersionItem(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.putCourseVersionItemRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
 }
 exports.CourseApi = CourseApi;
 /**

package/dist/apis/PlayerApi.d.ts

@@ -10,6 +10,17 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
+import { type ScormGetValueResponse } from '../models/ScormGetValueResponse';
+import { type ScormSetValueRequest } from '../models/ScormSetValueRequest';
+import { type ScormSetValueResponse } from '../models/ScormSetValueResponse';
+export interface CommitResourceScormSessionRequest {
+    sessionId: string;
+}
+export interface GetCourseVersionResourceAssetRequest {
+    courseVersionId: string;
+    itemId: string;
+    assetPath: string;
+}
 export interface GetDispatchScormPlayerRequest {
     sessionId: string;
 }
@@ -31,6 +42,13 @@ export interface GetPdfPlayerRequest {
 export interface GetQuizPlayerRequest {
     sessionId: string;
 }
+export interface GetResourceScormValueRequest {
+    sessionId: string;
+    key: string;
+}
+export interface GetResourceSessionPlayerRequest {
+    sessionId: string;
+}
 export interface GetScormAssetRequest {
     contentId: string;
     assetPath: string;
@@ -44,10 +62,44 @@ export interface GetVideoAssetRequest {
 export interface GetVideoPlayerRequest {
     sessionId: string;
 }
+export interface InitializeResourceScormSessionRequest {
+    sessionId: string;
+}
+export interface SetResourceScormValueRequest {
+    sessionId: string;
+    scormSetValueRequest: ScormSetValueRequest;
+}
+export interface TerminateResourceScormSessionRequest {
+    sessionId: string;
+}
 /**
  *
  */
 export declare class PlayerApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for commitResourceScormSession without sending the request
+     */
+    commitResourceScormSessionRequestOpts(requestParameters: CommitResourceScormSessionRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Commit a reusable SCORM resource session
+     */
+    commitResourceScormSessionRaw(requestParameters: CommitResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Commit a reusable SCORM resource session
+     */
+    commitResourceScormSession(requestParameters: CommitResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for getCourseVersionResourceAsset without sending the request
+     */
+    getCourseVersionResourceAssetRequestOpts(requestParameters: GetCourseVersionResourceAssetRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Stream an asset from an exact course and resource version
+     */
+    getCourseVersionResourceAssetRaw(requestParameters: GetCourseVersionResourceAssetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blob>>;
+    /**
+     * Stream an asset from an exact course and resource version
+     */
+    getCourseVersionResourceAsset(requestParameters: GetCourseVersionResourceAssetRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blob>;
     /**
      * Creates request options for getDispatchScormPlayer without sending the request
      */
@@ -132,6 +184,30 @@ export declare class PlayerApi extends runtime.BaseAPI {
      * Quiz player HTML page
      */
     getQuizPlayer(requestParameters: GetQuizPlayerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for getResourceScormValue without sending the request
+     */
+    getResourceScormValueRequestOpts(requestParameters: GetResourceScormValueRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Read a CMI value from a reusable SCORM resource session
+     */
+    getResourceScormValueRaw(requestParameters: GetResourceScormValueRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ScormGetValueResponse>>;
+    /**
+     * Read a CMI value from a reusable SCORM resource session
+     */
+    getResourceScormValue(requestParameters: GetResourceScormValueRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ScormGetValueResponse>;
+    /**
+     * Creates request options for getResourceSessionPlayer without sending the request
+     */
+    getResourceSessionPlayerRequestOpts(requestParameters: GetResourceSessionPlayerRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Serve the player for a version-pinned reusable resource session
+     */
+    getResourceSessionPlayerRaw(requestParameters: GetResourceSessionPlayerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>>;
+    /**
+     * Serve the player for a version-pinned reusable resource session
+     */
+    getResourceSessionPlayer(requestParameters: GetResourceSessionPlayerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string>;
     /**
      * Creates request options for getScormAsset without sending the request
      */
@@ -180,4 +256,40 @@ export declare class PlayerApi extends runtime.BaseAPI {
      * Video player HTML page
      */
     getVideoPlayer(requestParameters: GetVideoPlayerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for initializeResourceScormSession without sending the request
+     */
+    initializeResourceScormSessionRequestOpts(requestParameters: InitializeResourceScormSessionRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Initialize a reusable SCORM resource session
+     */
+    initializeResourceScormSessionRaw(requestParameters: InitializeResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Initialize a reusable SCORM resource session
+     */
+    initializeResourceScormSession(requestParameters: InitializeResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for setResourceScormValue without sending the request
+     */
+    setResourceScormValueRequestOpts(requestParameters: SetResourceScormValueRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Store a CMI value in a reusable SCORM resource session
+     */
+    setResourceScormValueRaw(requestParameters: SetResourceScormValueRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ScormSetValueResponse>>;
+    /**
+     * Store a CMI value in a reusable SCORM resource session
+     */
+    setResourceScormValue(requestParameters: SetResourceScormValueRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ScormSetValueResponse>;
+    /**
+     * Creates request options for terminateResourceScormSession without sending the request
+     */
+    terminateResourceScormSessionRequestOpts(requestParameters: TerminateResourceScormSessionRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Terminate a reusable SCORM resource session
+     */
+    terminateResourceScormSessionRaw(requestParameters: TerminateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Terminate a reusable SCORM resource session
+     */
+    terminateResourceScormSession(requestParameters: TerminateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
 }