@easyedu/js-lsm-api 1.118.0 → 1.119.0

package/src/apis/DispatchApi.ts

@@ -13,16 +13,180 @@
  */
 
 import * as runtime from '../runtime';
+import {
+    type DispatchTokenResponse,
+    DispatchTokenResponseFromJSON,
+    DispatchTokenResponseToJSON,
+} from '../models/DispatchTokenResponse';
+import {
+    type GetDispatchCourse,
+    GetDispatchCourseFromJSON,
+    GetDispatchCourseToJSON,
+} from '../models/GetDispatchCourse';
+import {
+    type GetDispatchRollup,
+    GetDispatchRollupFromJSON,
+    GetDispatchRollupToJSON,
+} from '../models/GetDispatchRollup';
+import {
+    type GetLibraryQuizResult,
+    GetLibraryQuizResultFromJSON,
+    GetLibraryQuizResultToJSON,
+} from '../models/GetLibraryQuizResult';
+import {
+    type GetLibraryQuizSession,
+    GetLibraryQuizSessionFromJSON,
+    GetLibraryQuizSessionToJSON,
+} from '../models/GetLibraryQuizSession';
+import {
+    type PostDispatchItemLaunch,
+    PostDispatchItemLaunchFromJSON,
+    PostDispatchItemLaunchToJSON,
+} from '../models/PostDispatchItemLaunch';
+import {
+    type PostDispatchItemLaunchResponse,
+    PostDispatchItemLaunchResponseFromJSON,
+    PostDispatchItemLaunchResponseToJSON,
+} from '../models/PostDispatchItemLaunchResponse';
+import {
+    type PostDispatchLaunch,
+    PostDispatchLaunchFromJSON,
+    PostDispatchLaunchToJSON,
+} from '../models/PostDispatchLaunch';
+import {
+    type PostDispatchLaunchResponse,
+    PostDispatchLaunchResponseFromJSON,
+    PostDispatchLaunchResponseToJSON,
+} from '../models/PostDispatchLaunchResponse';
+import {
+    type PostDispatchTokenExchange,
+    PostDispatchTokenExchangeFromJSON,
+    PostDispatchTokenExchangeToJSON,
+} from '../models/PostDispatchTokenExchange';
+import {
+    type PutLibraryQuizSessionAnswer,
+    PutLibraryQuizSessionAnswerFromJSON,
+    PutLibraryQuizSessionAnswerToJSON,
+} from '../models/PutLibraryQuizSessionAnswer';
+
+export interface GetDispatchQuizSessionRequest {
+    sessionId: string;
+}
 
 export interface GetDispatchRollupRequest {
     dispatchPackageId: string;
 }
 
+export interface PostDispatchItemLaunchRequest {
+    itemId: string;
+    postDispatchItemLaunch?: PostDispatchItemLaunch;
+}
+
+export interface PostDispatchLaunchRequest {
+    postDispatchLaunch: PostDispatchLaunch;
+}
+
+export interface PostDispatchQuizSessionSubmitRequest {
+    sessionId: string;
+}
+
+export interface PostDispatchTokenExchangeRequest {
+    postDispatchTokenExchange: PostDispatchTokenExchange;
+}
+
+export interface PutDispatchQuizSessionAnswerRequest {
+    sessionId: string;
+    sessionQuestionId: string;
+    putLibraryQuizSessionAnswer: PutLibraryQuizSessionAnswer;
+}
+
 /**
  * 
  */
 export class DispatchApi extends runtime.BaseAPI {
 
+    /**
+     * Creates request options for getDispatchCourse without sending the request
+     */
+    async getDispatchCourseRequestOpts(): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/dispatch/runtime/course`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get the registration-scoped hosted course snapshot
+     */
+    async getDispatchCourseRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetDispatchCourse>> {
+        const requestOptions = await this.getDispatchCourseRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetDispatchCourseFromJSON(jsonValue));
+    }
+
+    /**
+     * Get the registration-scoped hosted course snapshot
+     */
+    async getDispatchCourse(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetDispatchCourse> {
+        const response = await this.getDispatchCourseRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getDispatchQuizSession without sending the request
+     */
+    async getDispatchQuizSessionRequestOpts(requestParameters: GetDispatchQuizSessionRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sessionId'] == null) {
+            throw new runtime.RequiredError(
+                'sessionId',
+                'Required parameter "sessionId" was null or undefined when calling getDispatchQuizSession().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        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
+     */
+    async getDispatchQuizSessionRaw(requestParameters: GetDispatchQuizSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetLibraryQuizSession>> {
+        const requestOptions = await this.getDispatchQuizSessionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetLibraryQuizSessionFromJSON(jsonValue));
+    }
+
+    /**
+     * Get a registration-owned native quiz session
+     */
+    async getDispatchQuizSession(requestParameters: GetDispatchQuizSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetLibraryQuizSession> {
+        const response = await this.getDispatchQuizSessionRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for getDispatchRollup without sending the request
      */
@@ -53,28 +217,86 @@ export class DispatchApi extends runtime.BaseAPI {
     /**
      * Get dispatch package rollup data
      */
-    async getDispatchRollupRaw(requestParameters: GetDispatchRollupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async getDispatchRollupRaw(requestParameters: GetDispatchRollupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetDispatchRollup>> {
         const requestOptions = await this.getDispatchRollupRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetDispatchRollupFromJSON(jsonValue));
     }
 
     /**
      * Get dispatch package rollup data
      */
-    async getDispatchRollup(requestParameters: GetDispatchRollupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.getDispatchRollupRaw(requestParameters, initOverrides);
+    async getDispatchRollup(requestParameters: GetDispatchRollupRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetDispatchRollup> {
+        const response = await this.getDispatchRollupRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postDispatchItemLaunch without sending the request
+     */
+    async postDispatchItemLaunchRequestOpts(requestParameters: PostDispatchItemLaunchRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['itemId'] == null) {
+            throw new runtime.RequiredError(
+                'itemId',
+                'Required parameter "itemId" was null or undefined when calling postDispatchItemLaunch().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        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
+     */
+    async postDispatchItemLaunchRaw(requestParameters: PostDispatchItemLaunchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PostDispatchItemLaunchResponse>> {
+        const requestOptions = await this.postDispatchItemLaunchRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PostDispatchItemLaunchResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Start or resume a selected hosted course item
+     */
+    async postDispatchItemLaunch(requestParameters: PostDispatchItemLaunchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PostDispatchItemLaunchResponse> {
+        const response = await this.postDispatchItemLaunchRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
      * Creates request options for postDispatchLaunch without sending the request
      */
-    async postDispatchLaunchRequestOpts(): Promise<runtime.RequestOpts> {
+    async postDispatchLaunchRequestOpts(requestParameters: PostDispatchLaunchRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['postDispatchLaunch'] == null) {
+            throw new runtime.RequiredError(
+                'postDispatchLaunch',
+                'Required parameter "postDispatchLaunch" was null or undefined when calling postDispatchLaunch().'
+            );
+        }
+
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
+        headerParameters['Content-Type'] = 'application/json';
+
 
         let urlPath = `/dispatch/launch`;
 
@@ -83,24 +305,218 @@ export class DispatchApi extends runtime.BaseAPI {
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: PostDispatchLaunchToJSON(requestParameters['postDispatchLaunch']),
         };
     }
 
     /**
      * Launch a dispatch package
      */
-    async postDispatchLaunchRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        const requestOptions = await this.postDispatchLaunchRequestOpts();
+    async postDispatchLaunchRaw(requestParameters: PostDispatchLaunchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PostDispatchLaunchResponse>> {
+        const requestOptions = await this.postDispatchLaunchRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => PostDispatchLaunchResponseFromJSON(jsonValue));
     }
 
     /**
      * Launch a dispatch package
      */
-    async postDispatchLaunch(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.postDispatchLaunchRaw(initOverrides);
+    async postDispatchLaunch(requestParameters: PostDispatchLaunchRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PostDispatchLaunchResponse> {
+        const response = await this.postDispatchLaunchRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postDispatchQuizSessionSubmit without sending the request
+     */
+    async postDispatchQuizSessionSubmitRequestOpts(requestParameters: PostDispatchQuizSessionSubmitRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['sessionId'] == null) {
+            throw new runtime.RequiredError(
+                'sessionId',
+                'Required parameter "sessionId" was null or undefined when calling postDispatchQuizSessionSubmit().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        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
+     */
+    async postDispatchQuizSessionSubmitRaw(requestParameters: PostDispatchQuizSessionSubmitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetLibraryQuizResult>> {
+        const requestOptions = await this.postDispatchQuizSessionSubmitRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetLibraryQuizResultFromJSON(jsonValue));
+    }
+
+    /**
+     * Submit a registration-owned native quiz session
+     */
+    async postDispatchQuizSessionSubmit(requestParameters: PostDispatchQuizSessionSubmitRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetLibraryQuizResult> {
+        const response = await this.postDispatchQuizSessionSubmitRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postDispatchTokenExchange without sending the request
+     */
+    async postDispatchTokenExchangeRequestOpts(requestParameters: PostDispatchTokenExchangeRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['postDispatchTokenExchange'] == null) {
+            throw new runtime.RequiredError(
+                'postDispatchTokenExchange',
+                'Required parameter "postDispatchTokenExchange" was null or undefined when calling postDispatchTokenExchange().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        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
+     */
+    async postDispatchTokenExchangeRaw(requestParameters: PostDispatchTokenExchangeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DispatchTokenResponse>> {
+        const requestOptions = await this.postDispatchTokenExchangeRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => DispatchTokenResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Exchange a one-time hosted SCORM launch code
+     */
+    async postDispatchTokenExchange(requestParameters: PostDispatchTokenExchangeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DispatchTokenResponse> {
+        const response = await this.postDispatchTokenExchangeRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postDispatchTokenRefresh without sending the request
+     */
+    async postDispatchTokenRefreshRequestOpts(): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/dispatch/runtime/token/refresh`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Rotate a valid hosted SCORM access token
+     */
+    async postDispatchTokenRefreshRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<DispatchTokenResponse>> {
+        const requestOptions = await this.postDispatchTokenRefreshRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => DispatchTokenResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Rotate a valid hosted SCORM access token
+     */
+    async postDispatchTokenRefresh(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<DispatchTokenResponse> {
+        const response = await this.postDispatchTokenRefreshRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for putDispatchQuizSessionAnswer without sending the request
+     */
+    async putDispatchQuizSessionAnswerRequestOpts(requestParameters: PutDispatchQuizSessionAnswerRequest): Promise<runtime.RequestOpts> {
+        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: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        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
+     */
+    async putDispatchQuizSessionAnswerRaw(requestParameters: PutDispatchQuizSessionAnswerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetLibraryQuizSession>> {
+        const requestOptions = await this.putDispatchQuizSessionAnswerRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetLibraryQuizSessionFromJSON(jsonValue));
+    }
+
+    /**
+     * Save a registration-owned native quiz answer
+     */
+    async putDispatchQuizSessionAnswer(requestParameters: PutDispatchQuizSessionAnswerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetLibraryQuizSession> {
+        const response = await this.putDispatchQuizSessionAnswerRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
 }

package/src/apis/PlayerApi.ts

@@ -83,6 +83,21 @@ import {
     ScormGetValueResponseFromJSON,
     ScormGetValueResponseToJSON,
 } from '../models/ScormGetValueResponse';
+import {
+    type ScormNavigationRequest,
+    ScormNavigationRequestFromJSON,
+    ScormNavigationRequestToJSON,
+} from '../models/ScormNavigationRequest';
+import {
+    type ScormNavigationResponse,
+    ScormNavigationResponseFromJSON,
+    ScormNavigationResponseToJSON,
+} from '../models/ScormNavigationResponse';
+import {
+    type ScormRuntimeResponse,
+    ScormRuntimeResponseFromJSON,
+    ScormRuntimeResponseToJSON,
+} from '../models/ScormRuntimeResponse';
 import {
     type ScormSetValueRequest,
     ScormSetValueRequestFromJSON,
@@ -93,6 +108,11 @@ import {
     ScormSetValueResponseFromJSON,
     ScormSetValueResponseToJSON,
 } from '../models/ScormSetValueResponse';
+import {
+    type ScormTerminateResponse,
+    ScormTerminateResponseFromJSON,
+    ScormTerminateResponseToJSON,
+} from '../models/ScormTerminateResponse';
 
 export interface CommitResourceScormSessionRequest {
     sessionId: string;
@@ -183,6 +203,11 @@ export interface InitializeResourceScormSessionRequest {
     activityId?: string;
 }
 
+export interface NavigateResourceScormSessionRequest {
+    sessionId: string;
+    scormNavigationRequest: ScormNavigationRequest;
+}
+
 export interface PostResourceSessionActivityEventRequest {
     sessionId: string;
     activityId: string;
@@ -248,18 +273,19 @@ export class PlayerApi extends runtime.BaseAPI {
     /**
      * Commit a reusable SCORM resource session
      */
-    async commitResourceScormSessionRaw(requestParameters: CommitResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async commitResourceScormSessionRaw(requestParameters: CommitResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ScormRuntimeResponse>> {
         const requestOptions = await this.commitResourceScormSessionRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => ScormRuntimeResponseFromJSON(jsonValue));
     }
 
     /**
      * Commit a reusable SCORM resource session
      */
-    async commitResourceScormSession(requestParameters: CommitResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.commitResourceScormSessionRaw(requestParameters, initOverrides);
+    async commitResourceScormSession(requestParameters: CommitResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ScormRuntimeResponse> {
+        const response = await this.commitResourceScormSessionRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
@@ -983,18 +1009,74 @@ export class PlayerApi extends runtime.BaseAPI {
     /**
      * Initialize a reusable SCORM resource session
      */
-    async initializeResourceScormSessionRaw(requestParameters: InitializeResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async initializeResourceScormSessionRaw(requestParameters: InitializeResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ScormRuntimeResponse>> {
         const requestOptions = await this.initializeResourceScormSessionRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => ScormRuntimeResponseFromJSON(jsonValue));
     }
 
     /**
      * Initialize a reusable SCORM resource session
      */
-    async initializeResourceScormSession(requestParameters: InitializeResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.initializeResourceScormSessionRaw(requestParameters, initOverrides);
+    async initializeResourceScormSession(requestParameters: InitializeResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ScormRuntimeResponse> {
+        const response = await this.initializeResourceScormSessionRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for navigateResourceScormSession without sending the request
+     */
+    async navigateResourceScormSessionRequestOpts(requestParameters: NavigateResourceScormSessionRequest): Promise<runtime.RequestOpts> {
+        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: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        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
+     */
+    async navigateResourceScormSessionRaw(requestParameters: NavigateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ScormNavigationResponse>> {
+        const requestOptions = await this.navigateResourceScormSessionRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ScormNavigationResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Process a SCORM 2004 sequencing and navigation request
+     */
+    async navigateResourceScormSession(requestParameters: NavigateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ScormNavigationResponse> {
+        const response = await this.navigateResourceScormSessionRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
@@ -1253,18 +1335,19 @@ export class PlayerApi extends runtime.BaseAPI {
     /**
      * Terminate a reusable SCORM resource session
      */
-    async terminateResourceScormSessionRaw(requestParameters: TerminateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+    async terminateResourceScormSessionRaw(requestParameters: TerminateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ScormTerminateResponse>> {
         const requestOptions = await this.terminateResourceScormSessionRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => ScormTerminateResponseFromJSON(jsonValue));
     }
 
     /**
      * Terminate a reusable SCORM resource session
      */
-    async terminateResourceScormSession(requestParameters: TerminateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.terminateResourceScormSessionRaw(requestParameters, initOverrides);
+    async terminateResourceScormSession(requestParameters: TerminateResourceScormSessionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ScormTerminateResponse> {
+        const response = await this.terminateResourceScormSessionRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
 }