@easyedu/js-lsm-api 1.118.0 → 1.120.0

package/dist/esm/apis/DispatchApi.js

@@ -21,10 +21,95 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime';
+import { DispatchTokenResponseFromJSON, } from '../models/DispatchTokenResponse';
+import { GetDispatchCourseFromJSON, } from '../models/GetDispatchCourse';
+import { GetDispatchRollupFromJSON, } from '../models/GetDispatchRollup';
+import { GetLibraryQuizResultFromJSON, } from '../models/GetLibraryQuizResult';
+import { GetLibraryQuizSessionFromJSON, } from '../models/GetLibraryQuizSession';
+import { PostDispatchItemLaunchToJSON, } from '../models/PostDispatchItemLaunch';
+import { PostDispatchItemLaunchResponseFromJSON, } from '../models/PostDispatchItemLaunchResponse';
+import { PostDispatchLaunchToJSON, } from '../models/PostDispatchLaunch';
+import { PostDispatchLaunchResponseFromJSON, } from '../models/PostDispatchLaunchResponse';
+import { PostDispatchTokenExchangeToJSON, } from '../models/PostDispatchTokenExchange';
+import { PutLibraryQuizSessionAnswerToJSON, } from '../models/PutLibraryQuizSessionAnswer';
 /**
  *
  */
 export class DispatchApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for getDispatchCourse without sending the request
+     */
+    getDispatchCourseRequestOpts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/dispatch/runtime/course`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Get the registration-scoped hosted course snapshot
+     */
+    getDispatchCourseRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getDispatchCourseRequestOpts();
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetDispatchCourseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get the registration-scoped hosted course snapshot
+     */
+    getDispatchCourse(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getDispatchCourseRaw(initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getDispatchQuizSession without sending the request
+     */
+    getDispatchQuizSessionRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['sessionId'] == null) {
+                throw new runtime.RequiredError('sessionId', 'Required parameter "sessionId" was null or undefined when calling getDispatchQuizSession().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/dispatch/runtime/quiz-sessions/{sessionId}`;
+            urlPath = urlPath.replace('{sessionId}', encodeURIComponent(String(requestParameters['sessionId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Get a registration-owned native quiz session
+     */
+    getDispatchQuizSessionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getDispatchQuizSessionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetLibraryQuizSessionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get a registration-owned native quiz session
+     */
+    getDispatchQuizSession(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getDispatchQuizSessionRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for getDispatchRollup without sending the request
      */
@@ -52,7 +137,7 @@ export class DispatchApi extends runtime.BaseAPI {
         return __awaiter(this, void 0, void 0, function* () {
             const requestOptions = yield this.getDispatchRollupRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetDispatchRollupFromJSON(jsonValue));
         });
     }
     /**
@@ -60,41 +145,251 @@ export class DispatchApi extends runtime.BaseAPI {
      */
     getDispatchRollup(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.getDispatchRollupRaw(requestParameters, initOverrides);
+            const response = yield this.getDispatchRollupRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postDispatchItemLaunch without sending the request
+     */
+    postDispatchItemLaunchRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['itemId'] == null) {
+                throw new runtime.RequiredError('itemId', 'Required parameter "itemId" was null or undefined when calling postDispatchItemLaunch().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/dispatch/runtime/items/{itemId}/launch`;
+            urlPath = urlPath.replace('{itemId}', encodeURIComponent(String(requestParameters['itemId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostDispatchItemLaunchToJSON(requestParameters['postDispatchItemLaunch']),
+            };
+        });
+    }
+    /**
+     * Start or resume a selected hosted course item
+     */
+    postDispatchItemLaunchRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postDispatchItemLaunchRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PostDispatchItemLaunchResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Start or resume a selected hosted course item
+     */
+    postDispatchItemLaunch(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postDispatchItemLaunchRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
     /**
      * Creates request options for postDispatchLaunch without sending the request
      */
-    postDispatchLaunchRequestOpts() {
+    postDispatchLaunchRequestOpts(requestParameters) {
         return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['postDispatchLaunch'] == null) {
+                throw new runtime.RequiredError('postDispatchLaunch', 'Required parameter "postDispatchLaunch" was null or undefined when calling postDispatchLaunch().');
+            }
             const queryParameters = {};
             const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
             let urlPath = `/dispatch/launch`;
             return {
                 path: urlPath,
                 method: 'POST',
                 headers: headerParameters,
                 query: queryParameters,
+                body: PostDispatchLaunchToJSON(requestParameters['postDispatchLaunch']),
             };
         });
     }
     /**
      * Launch a dispatch package
      */
-    postDispatchLaunchRaw(initOverrides) {
+    postDispatchLaunchRaw(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            const requestOptions = yield this.postDispatchLaunchRequestOpts();
+            const requestOptions = yield this.postDispatchLaunchRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => PostDispatchLaunchResponseFromJSON(jsonValue));
         });
     }
     /**
      * Launch a dispatch package
      */
-    postDispatchLaunch(initOverrides) {
+    postDispatchLaunch(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postDispatchLaunchRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postDispatchQuizSessionSubmit without sending the request
+     */
+    postDispatchQuizSessionSubmitRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['sessionId'] == null) {
+                throw new runtime.RequiredError('sessionId', 'Required parameter "sessionId" was null or undefined when calling postDispatchQuizSessionSubmit().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/dispatch/runtime/quiz-sessions/{sessionId}/submit`;
+            urlPath = urlPath.replace('{sessionId}', encodeURIComponent(String(requestParameters['sessionId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Submit a registration-owned native quiz session
+     */
+    postDispatchQuizSessionSubmitRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postDispatchQuizSessionSubmitRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetLibraryQuizResultFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Submit a registration-owned native quiz session
+     */
+    postDispatchQuizSessionSubmit(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postDispatchQuizSessionSubmitRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postDispatchTokenExchange without sending the request
+     */
+    postDispatchTokenExchangeRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['postDispatchTokenExchange'] == null) {
+                throw new runtime.RequiredError('postDispatchTokenExchange', 'Required parameter "postDispatchTokenExchange" was null or undefined when calling postDispatchTokenExchange().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/dispatch/runtime/token`;
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostDispatchTokenExchangeToJSON(requestParameters['postDispatchTokenExchange']),
+            };
+        });
+    }
+    /**
+     * Exchange a one-time hosted SCORM launch code
+     */
+    postDispatchTokenExchangeRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postDispatchTokenExchangeRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => DispatchTokenResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Exchange a one-time hosted SCORM launch code
+     */
+    postDispatchTokenExchange(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postDispatchTokenExchangeRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postDispatchTokenRefresh without sending the request
+     */
+    postDispatchTokenRefreshRequestOpts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/dispatch/runtime/token/refresh`;
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Rotate a valid hosted SCORM access token
+     */
+    postDispatchTokenRefreshRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postDispatchTokenRefreshRequestOpts();
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => DispatchTokenResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Rotate a valid hosted SCORM access token
+     */
+    postDispatchTokenRefresh(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postDispatchTokenRefreshRaw(initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for putDispatchQuizSessionAnswer without sending the request
+     */
+    putDispatchQuizSessionAnswerRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['sessionId'] == null) {
+                throw new runtime.RequiredError('sessionId', 'Required parameter "sessionId" was null or undefined when calling putDispatchQuizSessionAnswer().');
+            }
+            if (requestParameters['sessionQuestionId'] == null) {
+                throw new runtime.RequiredError('sessionQuestionId', 'Required parameter "sessionQuestionId" was null or undefined when calling putDispatchQuizSessionAnswer().');
+            }
+            if (requestParameters['putLibraryQuizSessionAnswer'] == null) {
+                throw new runtime.RequiredError('putLibraryQuizSessionAnswer', 'Required parameter "putLibraryQuizSessionAnswer" was null or undefined when calling putDispatchQuizSessionAnswer().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/dispatch/runtime/quiz-sessions/{sessionId}/answers/{sessionQuestionId}`;
+            urlPath = urlPath.replace('{sessionId}', encodeURIComponent(String(requestParameters['sessionId'])));
+            urlPath = urlPath.replace('{sessionQuestionId}', encodeURIComponent(String(requestParameters['sessionQuestionId'])));
+            return {
+                path: urlPath,
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PutLibraryQuizSessionAnswerToJSON(requestParameters['putLibraryQuizSessionAnswer']),
+            };
+        });
+    }
+    /**
+     * Save a registration-owned native quiz answer
+     */
+    putDispatchQuizSessionAnswerRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.putDispatchQuizSessionAnswerRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetLibraryQuizSessionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Save a registration-owned native quiz answer
+     */
+    putDispatchQuizSessionAnswer(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.postDispatchLaunchRaw(initOverrides);
+            const response = yield this.putDispatchQuizSessionAnswerRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
 }

package/dist/esm/apis/PlayerApi.d.ts

@@ -23,8 +23,12 @@ import { type PutResourceSessionOverride } from '../models/PutResourceSessionOve
 import { type ResourceSessionEnvironment } from '../models/ResourceSessionEnvironment';
 import { type ResourceType } from '../models/ResourceType';
 import { type ScormGetValueResponse } from '../models/ScormGetValueResponse';
+import { type ScormNavigationRequest } from '../models/ScormNavigationRequest';
+import { type ScormNavigationResponse } from '../models/ScormNavigationResponse';
+import { type ScormRuntimeResponse } from '../models/ScormRuntimeResponse';
 import { type ScormSetValueRequest } from '../models/ScormSetValueRequest';
 import { type ScormSetValueResponse } from '../models/ScormSetValueResponse';
+import { type ScormTerminateResponse } from '../models/ScormTerminateResponse';
 export interface CommitResourceScormSessionRequest {
     sessionId: string;
     activityId?: string;
@@ -100,6 +104,10 @@ export interface InitializeResourceScormSessionRequest {
     sessionId: string;
     activityId?: string;
 }
+export interface NavigateResourceScormSessionRequest {
+    sessionId: string;
+    scormNavigationRequest: ScormNavigationRequest;
+}
 export interface PostResourceSessionActivityEventRequest {
     sessionId: string;
     activityId: string;
@@ -132,11 +140,11 @@ export declare class PlayerApi extends runtime.BaseAPI {
     /**
      * Commit a reusable SCORM resource session
      */
-    commitResourceScormSessionRaw(requestParameters: CommitResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    commitResourceScormSessionRaw(requestParameters: CommitResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ScormRuntimeResponse>>;
     /**
      * Commit a reusable SCORM resource session
      */
-    commitResourceScormSession(requestParameters: CommitResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    commitResourceScormSession(requestParameters: CommitResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ScormRuntimeResponse>;
     /**
      * Creates request options for getCourseVersionResourceAsset without sending the request
      */
@@ -288,11 +296,23 @@ export declare class PlayerApi extends runtime.BaseAPI {
     /**
      * Initialize a reusable SCORM resource session
      */
-    initializeResourceScormSessionRaw(requestParameters: InitializeResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    initializeResourceScormSessionRaw(requestParameters: InitializeResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ScormRuntimeResponse>>;
     /**
      * Initialize a reusable SCORM resource session
      */
-    initializeResourceScormSession(requestParameters: InitializeResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    initializeResourceScormSession(requestParameters: InitializeResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ScormRuntimeResponse>;
+    /**
+     * Creates request options for navigateResourceScormSession without sending the request
+     */
+    navigateResourceScormSessionRequestOpts(requestParameters: NavigateResourceScormSessionRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Process a SCORM 2004 sequencing and navigation request
+     */
+    navigateResourceScormSessionRaw(requestParameters: NavigateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ScormNavigationResponse>>;
+    /**
+     * Process a SCORM 2004 sequencing and navigation request
+     */
+    navigateResourceScormSession(requestParameters: NavigateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ScormNavigationResponse>;
     /**
      * Creates request options for postResourceSessionActivityEvent without sending the request
      */
@@ -348,11 +368,11 @@ export declare class PlayerApi extends runtime.BaseAPI {
     /**
      * Terminate a reusable SCORM resource session
      */
-    terminateResourceScormSessionRaw(requestParameters: TerminateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    terminateResourceScormSessionRaw(requestParameters: TerminateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ScormTerminateResponse>>;
     /**
      * Terminate a reusable SCORM resource session
      */
-    terminateResourceScormSession(requestParameters: TerminateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    terminateResourceScormSession(requestParameters: TerminateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ScormTerminateResponse>;
 }
 /**
  * @export

package/dist/esm/apis/PlayerApi.js

@@ -32,8 +32,12 @@ import { GetResourceSessionScormDataFromJSON, } from '../models/GetResourceSessi
 import { PostResourceSessionActivityEventToJSON, } from '../models/PostResourceSessionActivityEvent';
 import { PutResourceSessionOverrideToJSON, } from '../models/PutResourceSessionOverride';
 import { ScormGetValueResponseFromJSON, } from '../models/ScormGetValueResponse';
+import { ScormNavigationRequestToJSON, } from '../models/ScormNavigationRequest';
+import { ScormNavigationResponseFromJSON, } from '../models/ScormNavigationResponse';
+import { ScormRuntimeResponseFromJSON, } from '../models/ScormRuntimeResponse';
 import { ScormSetValueRequestToJSON, } from '../models/ScormSetValueRequest';
 import { ScormSetValueResponseFromJSON, } from '../models/ScormSetValueResponse';
+import { ScormTerminateResponseFromJSON, } from '../models/ScormTerminateResponse';
 /**
  *
  */
@@ -68,7 +72,7 @@ export class PlayerApi extends runtime.BaseAPI {
         return __awaiter(this, void 0, void 0, function* () {
             const requestOptions = yield this.commitResourceScormSessionRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ScormRuntimeResponseFromJSON(jsonValue));
         });
     }
     /**
@@ -76,7 +80,8 @@ export class PlayerApi extends runtime.BaseAPI {
      */
     commitResourceScormSession(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.commitResourceScormSessionRaw(requestParameters, initOverrides);
+            const response = yield this.commitResourceScormSessionRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
     /**
@@ -685,7 +690,7 @@ export class PlayerApi extends runtime.BaseAPI {
         return __awaiter(this, void 0, void 0, function* () {
             const requestOptions = yield this.initializeResourceScormSessionRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ScormRuntimeResponseFromJSON(jsonValue));
         });
     }
     /**
@@ -693,7 +698,52 @@ export class PlayerApi extends runtime.BaseAPI {
      */
     initializeResourceScormSession(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.initializeResourceScormSessionRaw(requestParameters, initOverrides);
+            const response = yield this.initializeResourceScormSessionRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for navigateResourceScormSession without sending the request
+     */
+    navigateResourceScormSessionRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['sessionId'] == null) {
+                throw new runtime.RequiredError('sessionId', 'Required parameter "sessionId" was null or undefined when calling navigateResourceScormSession().');
+            }
+            if (requestParameters['scormNavigationRequest'] == null) {
+                throw new runtime.RequiredError('scormNavigationRequest', 'Required parameter "scormNavigationRequest" was null or undefined when calling navigateResourceScormSession().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/resource/sessions/{sessionId}/navigation`;
+            urlPath = urlPath.replace('{sessionId}', encodeURIComponent(String(requestParameters['sessionId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: ScormNavigationRequestToJSON(requestParameters['scormNavigationRequest']),
+            };
+        });
+    }
+    /**
+     * Process a SCORM 2004 sequencing and navigation request
+     */
+    navigateResourceScormSessionRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.navigateResourceScormSessionRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ScormNavigationResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Process a SCORM 2004 sequencing and navigation request
+     */
+    navigateResourceScormSession(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.navigateResourceScormSessionRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
     /**
@@ -904,7 +954,7 @@ export class PlayerApi extends runtime.BaseAPI {
         return __awaiter(this, void 0, void 0, function* () {
             const requestOptions = yield this.terminateResourceScormSessionRequestOpts(requestParameters);
             const response = yield this.request(requestOptions, initOverrides);
-            return new runtime.VoidApiResponse(response);
+            return new runtime.JSONApiResponse(response, (jsonValue) => ScormTerminateResponseFromJSON(jsonValue));
         });
     }
     /**
@@ -912,7 +962,8 @@ export class PlayerApi extends runtime.BaseAPI {
      */
     terminateResourceScormSession(requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function* () {
-            yield this.terminateResourceScormSessionRaw(requestParameters, initOverrides);
+            const response = yield this.terminateResourceScormSessionRaw(requestParameters, initOverrides);
+            return yield response.value();
         });
     }
 }

package/dist/esm/models/DispatchTokenResponse.d.ts

@@ -0,0 +1,57 @@
+/**
+ * LMS API
+ * LMS API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface DispatchTokenResponse
+ */
+export interface DispatchTokenResponse {
+    /**
+     *
+     * @type {string}
+     * @memberof DispatchTokenResponse
+     */
+    accessToken: string;
+    /**
+     *
+     * @type {DispatchTokenResponseTokenTypeEnum}
+     * @memberof DispatchTokenResponse
+     */
+    tokenType: DispatchTokenResponseTokenTypeEnum;
+    /**
+     *
+     * @type {string}
+     * @memberof DispatchTokenResponse
+     */
+    registrationId: string;
+    /**
+     *
+     * @type {number}
+     * @memberof DispatchTokenResponse
+     */
+    expiresAt: number;
+}
+/**
+ * @export
+ */
+export declare const DispatchTokenResponseTokenTypeEnum: {
+    readonly Dispatch: "Dispatch";
+};
+export type DispatchTokenResponseTokenTypeEnum = typeof DispatchTokenResponseTokenTypeEnum[keyof typeof DispatchTokenResponseTokenTypeEnum];
+/**
+ * Check if a given object implements the DispatchTokenResponse interface.
+ */
+export declare function instanceOfDispatchTokenResponse(value: object): value is DispatchTokenResponse;
+export declare function DispatchTokenResponseFromJSON(json: any): DispatchTokenResponse;
+export declare function DispatchTokenResponseFromJSONTyped(json: any, ignoreDiscriminator: boolean): DispatchTokenResponse;
+export declare function DispatchTokenResponseToJSON(json: any): DispatchTokenResponse;
+export declare function DispatchTokenResponseToJSONTyped(value?: DispatchTokenResponse | null, ignoreDiscriminator?: boolean): any;

package/dist/esm/models/DispatchTokenResponse.js

@@ -0,0 +1,61 @@
+/* tslint:disable */
+/* eslint-disable */
+/**
+ * LMS API
+ * LMS API
+ *
+ * The version of the OpenAPI document: 1.0.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ * @export
+ */
+export const DispatchTokenResponseTokenTypeEnum = {
+    Dispatch: 'Dispatch'
+};
+/**
+ * Check if a given object implements the DispatchTokenResponse interface.
+ */
+export function instanceOfDispatchTokenResponse(value) {
+    if (!('accessToken' in value) || value['accessToken'] === undefined)
+        return false;
+    if (!('tokenType' in value) || value['tokenType'] === undefined)
+        return false;
+    if (!('registrationId' in value) || value['registrationId'] === undefined)
+        return false;
+    if (!('expiresAt' in value) || value['expiresAt'] === undefined)
+        return false;
+    return true;
+}
+export function DispatchTokenResponseFromJSON(json) {
+    return DispatchTokenResponseFromJSONTyped(json, false);
+}
+export function DispatchTokenResponseFromJSONTyped(json, ignoreDiscriminator) {
+    if (json == null) {
+        return json;
+    }
+    return {
+        'accessToken': json['access_token'],
+        'tokenType': json['token_type'],
+        'registrationId': json['registration_id'],
+        'expiresAt': json['expires_at'],
+    };
+}
+export function DispatchTokenResponseToJSON(json) {
+    return DispatchTokenResponseToJSONTyped(json, false);
+}
+export function DispatchTokenResponseToJSONTyped(value, ignoreDiscriminator = false) {
+    if (value == null) {
+        return value;
+    }
+    return {
+        'access_token': value['accessToken'],
+        'token_type': value['tokenType'],
+        'registration_id': value['registrationId'],
+        'expires_at': value['expiresAt'],
+    };
+}