@easyedu/js-lsm-api 1.83.0 → 1.84.0

package/dist/apis/PlayerApi.js

@@ -24,10 +24,98 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.PlayerApi = void 0;
 const runtime = require("../runtime");
+const ScormGetValueResponse_1 = require("../models/ScormGetValueResponse");
+const ScormSetValueRequest_1 = require("../models/ScormSetValueRequest");
+const ScormSetValueResponse_1 = require("../models/ScormSetValueResponse");
 /**
  *
  */
 class PlayerApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for commitResourceScormSession without sending the request
+     */
+    commitResourceScormSessionRequestOpts(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 commitResourceScormSession().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/resource/sessions/{sessionId}/commit`;
+            urlPath = urlPath.replace('{sessionId}', encodeURIComponent(String(requestParameters['sessionId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Commit a reusable SCORM resource session
+     */
+    commitResourceScormSessionRaw(requestParameters, initOverrides) {
+        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);
+        });
+    }
+    /**
+     * Commit a reusable SCORM resource session
+     */
+    commitResourceScormSession(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.commitResourceScormSessionRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Creates request options for getCourseVersionResourceAsset without sending the request
+     */
+    getCourseVersionResourceAssetRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['courseVersionId'] == null) {
+                throw new runtime.RequiredError('courseVersionId', 'Required parameter "courseVersionId" was null or undefined when calling getCourseVersionResourceAsset().');
+            }
+            if (requestParameters['itemId'] == null) {
+                throw new runtime.RequiredError('itemId', 'Required parameter "itemId" was null or undefined when calling getCourseVersionResourceAsset().');
+            }
+            if (requestParameters['assetPath'] == null) {
+                throw new runtime.RequiredError('assetPath', 'Required parameter "assetPath" was null or undefined when calling getCourseVersionResourceAsset().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/resource/course-versions/{courseVersionId}/items/{itemId}/asset/{assetPath}`;
+            urlPath = urlPath.replace('{courseVersionId}', encodeURIComponent(String(requestParameters['courseVersionId'])));
+            urlPath = urlPath.replace('{itemId}', encodeURIComponent(String(requestParameters['itemId'])));
+            urlPath = urlPath.replace('{assetPath}', encodeURIComponent(String(requestParameters['assetPath'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Stream an asset from an exact course and resource version
+     */
+    getCourseVersionResourceAssetRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getCourseVersionResourceAssetRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.BlobApiResponse(response);
+        });
+    }
+    /**
+     * Stream an asset from an exact course and resource version
+     */
+    getCourseVersionResourceAsset(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getCourseVersionResourceAssetRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for getDispatchScormPlayer without sending the request
      */
@@ -294,6 +382,95 @@ class PlayerApi extends runtime.BaseAPI {
             yield this.getQuizPlayerRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Creates request options for getResourceScormValue without sending the request
+     */
+    getResourceScormValueRequestOpts(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 getResourceScormValue().');
+            }
+            if (requestParameters['key'] == null) {
+                throw new runtime.RequiredError('key', 'Required parameter "key" was null or undefined when calling getResourceScormValue().');
+            }
+            const queryParameters = {};
+            if (requestParameters['key'] != null) {
+                queryParameters['key'] = requestParameters['key'];
+            }
+            const headerParameters = {};
+            let urlPath = `/resource/sessions/{sessionId}/get-value`;
+            urlPath = urlPath.replace('{sessionId}', encodeURIComponent(String(requestParameters['sessionId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Read a CMI value from a reusable SCORM resource session
+     */
+    getResourceScormValueRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getResourceScormValueRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, ScormGetValueResponse_1.ScormGetValueResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Read a CMI value from a reusable SCORM resource session
+     */
+    getResourceScormValue(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getResourceScormValueRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getResourceSessionPlayer without sending the request
+     */
+    getResourceSessionPlayerRequestOpts(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 getResourceSessionPlayer().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/resource/sessions/{sessionId}/player`;
+            urlPath = urlPath.replace('{sessionId}', encodeURIComponent(String(requestParameters['sessionId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Serve the player for a version-pinned reusable resource session
+     */
+    getResourceSessionPlayerRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getResourceSessionPlayerRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            if (this.isJsonMime(response.headers.get('content-type'))) {
+                return new runtime.JSONApiResponse(response);
+            }
+            else {
+                return new runtime.TextApiResponse(response);
+            }
+        });
+    }
+    /**
+     * Serve the player for a version-pinned reusable resource session
+     */
+    getResourceSessionPlayer(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getResourceSessionPlayerRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for getScormAsset without sending the request
      */
@@ -450,5 +627,125 @@ class PlayerApi extends runtime.BaseAPI {
             yield this.getVideoPlayerRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Creates request options for initializeResourceScormSession without sending the request
+     */
+    initializeResourceScormSessionRequestOpts(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 initializeResourceScormSession().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/resource/sessions/{sessionId}/initialize`;
+            urlPath = urlPath.replace('{sessionId}', encodeURIComponent(String(requestParameters['sessionId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Initialize a reusable SCORM resource session
+     */
+    initializeResourceScormSessionRaw(requestParameters, initOverrides) {
+        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);
+        });
+    }
+    /**
+     * Initialize a reusable SCORM resource session
+     */
+    initializeResourceScormSession(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.initializeResourceScormSessionRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Creates request options for setResourceScormValue without sending the request
+     */
+    setResourceScormValueRequestOpts(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 setResourceScormValue().');
+            }
+            if (requestParameters['scormSetValueRequest'] == null) {
+                throw new runtime.RequiredError('scormSetValueRequest', 'Required parameter "scormSetValueRequest" was null or undefined when calling setResourceScormValue().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/resource/sessions/{sessionId}/set-value`;
+            urlPath = urlPath.replace('{sessionId}', encodeURIComponent(String(requestParameters['sessionId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, ScormSetValueRequest_1.ScormSetValueRequestToJSON)(requestParameters['scormSetValueRequest']),
+            };
+        });
+    }
+    /**
+     * Store a CMI value in a reusable SCORM resource session
+     */
+    setResourceScormValueRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.setResourceScormValueRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, ScormSetValueResponse_1.ScormSetValueResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Store a CMI value in a reusable SCORM resource session
+     */
+    setResourceScormValue(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.setResourceScormValueRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for terminateResourceScormSession without sending the request
+     */
+    terminateResourceScormSessionRequestOpts(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 terminateResourceScormSession().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/resource/sessions/{sessionId}/terminate`;
+            urlPath = urlPath.replace('{sessionId}', encodeURIComponent(String(requestParameters['sessionId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Terminate a reusable SCORM resource session
+     */
+    terminateResourceScormSessionRaw(requestParameters, initOverrides) {
+        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);
+        });
+    }
+    /**
+     * Terminate a reusable SCORM resource session
+     */
+    terminateResourceScormSession(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.terminateResourceScormSessionRaw(requestParameters, initOverrides);
+        });
+    }
 }
 exports.PlayerApi = PlayerApi;

package/dist/apis/index.d.ts

@@ -1,6 +1,7 @@
 export * from './CertificateApi';
 export * from './ChatApi';
 export * from './ContentApi';
+export * from './ContentLibraryApi';
 export * from './CourseApi';
 export * from './CourseCatalogApi';
 export * from './CourseShareApi';

package/dist/apis/index.js

@@ -19,6 +19,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 __exportStar(require("./CertificateApi"), exports);
 __exportStar(require("./ChatApi"), exports);
 __exportStar(require("./ContentApi"), exports);
+__exportStar(require("./ContentLibraryApi"), exports);
 __exportStar(require("./CourseApi"), exports);
 __exportStar(require("./CourseCatalogApi"), exports);
 __exportStar(require("./CourseShareApi"), exports);

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

@@ -0,0 +1,290 @@
+/**
+ * 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.
+ */
+import * as runtime from '../runtime';
+import { type GetContentLibraryVersion } from '../models/GetContentLibraryVersion';
+import { type GetResource } from '../models/GetResource';
+import { type GetResourceList } from '../models/GetResourceList';
+import { type GetResourceUsage } from '../models/GetResourceUsage';
+import { type GetResourceVersionUpload } from '../models/GetResourceVersionUpload';
+import { type PostResource } from '../models/PostResource';
+import { type PostResourceVersion } from '../models/PostResourceVersion';
+import { type PostResourceVersionComplete } from '../models/PostResourceVersionComplete';
+import { type PostResourceVersionUpload } from '../models/PostResourceVersionUpload';
+import { type PutResource } from '../models/PutResource';
+import { type PutResourceVersion } from '../models/PutResourceVersion';
+import { type ResourceType } from '../models/ResourceType';
+export interface DeleteResourceVersionRequest {
+    resourceId: string;
+    versionId: string;
+}
+export interface GetContentLibraryItemListRequest {
+    kind?: string;
+    search?: string;
+    resourceType?: ResourceType;
+    page?: number;
+    pageSize?: number;
+}
+export interface GetResourceRequest {
+    resourceId: string;
+}
+export interface GetResourceListRequest {
+    search?: string;
+    resourceType?: ResourceType;
+    page?: number;
+    pageSize?: number;
+}
+export interface GetResourceUsageRequest {
+    resourceId: string;
+}
+export interface GetResourceVersionRequest {
+    resourceId: string;
+    versionId: string;
+}
+export interface PostResourceRequest {
+    postResource: PostResource;
+}
+export interface PostResourceArchiveRequest {
+    resourceId: string;
+}
+export interface PostResourceVersionRequest {
+    resourceId: string;
+    postResourceVersion?: PostResourceVersion;
+}
+export interface PostResourceVersionArchiveRequest {
+    resourceId: string;
+    versionId: string;
+}
+export interface PostResourceVersionPublishRequest {
+    resourceId: string;
+    versionId: string;
+}
+export interface PostResourceVersionUploadRequest {
+    resourceId: string;
+    versionId: string;
+    postResourceVersionUpload: PostResourceVersionUpload;
+}
+export interface PostResourceVersionUploadCompleteRequest {
+    resourceId: string;
+    versionId: string;
+    postResourceVersionComplete: PostResourceVersionComplete;
+}
+export interface PutResourceRequest {
+    resourceId: string;
+    putResource: PutResource;
+}
+export interface PutResourceVersionRequest {
+    resourceId: string;
+    versionId: string;
+    putResourceVersion: PutResourceVersion;
+}
+export interface PutResourceVersionUploadFileRequest {
+    resourceId: string;
+    versionId: string;
+    body: Blob;
+}
+/**
+ *
+ */
+export declare class ContentLibraryApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for deleteResourceVersion without sending the request
+     */
+    deleteResourceVersionRequestOpts(requestParameters: DeleteResourceVersionRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Discard an unreferenced draft resource version
+     */
+    deleteResourceVersionRaw(requestParameters: DeleteResourceVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Discard an unreferenced draft resource version
+     */
+    deleteResourceVersion(requestParameters: DeleteResourceVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+    /**
+     * Creates request options for getContentLibraryItemList without sending the request
+     */
+    getContentLibraryItemListRequestOpts(requestParameters: GetContentLibraryItemListRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Search Content Library items
+     */
+    getContentLibraryItemListRaw(requestParameters: GetContentLibraryItemListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetResourceList>>;
+    /**
+     * Search Content Library items
+     */
+    getContentLibraryItemList(requestParameters?: GetContentLibraryItemListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetResourceList>;
+    /**
+     * Creates request options for getResource without sending the request
+     */
+    getResourceRequestOpts(requestParameters: GetResourceRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Get a resource and all versions
+     */
+    getResourceRaw(requestParameters: GetResourceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetResource>>;
+    /**
+     * Get a resource and all versions
+     */
+    getResource(requestParameters: GetResourceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetResource>;
+    /**
+     * Creates request options for getResourceList without sending the request
+     */
+    getResourceListRequestOpts(requestParameters: GetResourceListRequest): Promise<runtime.RequestOpts>;
+    /**
+     * List reusable resources
+     */
+    getResourceListRaw(requestParameters: GetResourceListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetResourceList>>;
+    /**
+     * List reusable resources
+     */
+    getResourceList(requestParameters?: GetResourceListRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetResourceList>;
+    /**
+     * Creates request options for getResourceUsage without sending the request
+     */
+    getResourceUsageRequestOpts(requestParameters: GetResourceUsageRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Get course and learner usage for a resource
+     */
+    getResourceUsageRaw(requestParameters: GetResourceUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetResourceUsage>>;
+    /**
+     * Get course and learner usage for a resource
+     */
+    getResourceUsage(requestParameters: GetResourceUsageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetResourceUsage>;
+    /**
+     * Creates request options for getResourceVersion without sending the request
+     */
+    getResourceVersionRequestOpts(requestParameters: GetResourceVersionRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Get a resource version
+     */
+    getResourceVersionRaw(requestParameters: GetResourceVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetContentLibraryVersion>>;
+    /**
+     * Get a resource version
+     */
+    getResourceVersion(requestParameters: GetResourceVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetContentLibraryVersion>;
+    /**
+     * Creates request options for postResource without sending the request
+     */
+    postResourceRequestOpts(requestParameters: PostResourceRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Create a resource and its first draft version
+     */
+    postResourceRaw(requestParameters: PostResourceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetResource>>;
+    /**
+     * Create a resource and its first draft version
+     */
+    postResource(requestParameters: PostResourceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetResource>;
+    /**
+     * Creates request options for postResourceArchive without sending the request
+     */
+    postResourceArchiveRequestOpts(requestParameters: PostResourceArchiveRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Archive a logical resource
+     */
+    postResourceArchiveRaw(requestParameters: PostResourceArchiveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetResource>>;
+    /**
+     * Archive a logical resource
+     */
+    postResourceArchive(requestParameters: PostResourceArchiveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetResource>;
+    /**
+     * Creates request options for postResourceVersion without sending the request
+     */
+    postResourceVersionRequestOpts(requestParameters: PostResourceVersionRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Create the next draft resource version
+     */
+    postResourceVersionRaw(requestParameters: PostResourceVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetContentLibraryVersion>>;
+    /**
+     * Create the next draft resource version
+     */
+    postResourceVersion(requestParameters: PostResourceVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetContentLibraryVersion>;
+    /**
+     * Creates request options for postResourceVersionArchive without sending the request
+     */
+    postResourceVersionArchiveRequestOpts(requestParameters: PostResourceVersionArchiveRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Archive a published resource version
+     */
+    postResourceVersionArchiveRaw(requestParameters: PostResourceVersionArchiveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetContentLibraryVersion>>;
+    /**
+     * Archive a published resource version
+     */
+    postResourceVersionArchive(requestParameters: PostResourceVersionArchiveRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetContentLibraryVersion>;
+    /**
+     * Creates request options for postResourceVersionPublish without sending the request
+     */
+    postResourceVersionPublishRequestOpts(requestParameters: PostResourceVersionPublishRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Publish an immutable resource version
+     */
+    postResourceVersionPublishRaw(requestParameters: PostResourceVersionPublishRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetContentLibraryVersion>>;
+    /**
+     * Publish an immutable resource version
+     */
+    postResourceVersionPublish(requestParameters: PostResourceVersionPublishRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetContentLibraryVersion>;
+    /**
+     * Creates request options for postResourceVersionUpload without sending the request
+     */
+    postResourceVersionUploadRequestOpts(requestParameters: PostResourceVersionUploadRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Initialize a version-scoped file upload
+     */
+    postResourceVersionUploadRaw(requestParameters: PostResourceVersionUploadRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetResourceVersionUpload>>;
+    /**
+     * Initialize a version-scoped file upload
+     */
+    postResourceVersionUpload(requestParameters: PostResourceVersionUploadRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetResourceVersionUpload>;
+    /**
+     * Creates request options for postResourceVersionUploadComplete without sending the request
+     */
+    postResourceVersionUploadCompleteRequestOpts(requestParameters: PostResourceVersionUploadCompleteRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Verify and complete a resource upload
+     */
+    postResourceVersionUploadCompleteRaw(requestParameters: PostResourceVersionUploadCompleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetContentLibraryVersion>>;
+    /**
+     * Verify and complete a resource upload
+     */
+    postResourceVersionUploadComplete(requestParameters: PostResourceVersionUploadCompleteRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetContentLibraryVersion>;
+    /**
+     * Creates request options for putResource without sending the request
+     */
+    putResourceRequestOpts(requestParameters: PutResourceRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Update resource library metadata
+     */
+    putResourceRaw(requestParameters: PutResourceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetResource>>;
+    /**
+     * Update resource library metadata
+     */
+    putResource(requestParameters: PutResourceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetResource>;
+    /**
+     * Creates request options for putResourceVersion without sending the request
+     */
+    putResourceVersionRequestOpts(requestParameters: PutResourceVersionRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Edit a draft resource version
+     */
+    putResourceVersionRaw(requestParameters: PutResourceVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetContentLibraryVersion>>;
+    /**
+     * Edit a draft resource version
+     */
+    putResourceVersion(requestParameters: PutResourceVersionRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetContentLibraryVersion>;
+    /**
+     * Creates request options for putResourceVersionUploadFile without sending the request
+     */
+    putResourceVersionUploadFileRequestOpts(requestParameters: PutResourceVersionUploadFileRequest): Promise<runtime.RequestOpts>;
+    /**
+     * Upload bytes for a draft resource version
+     */
+    putResourceVersionUploadFileRaw(requestParameters: PutResourceVersionUploadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Upload bytes for a draft resource version
+     */
+    putResourceVersionUploadFile(requestParameters: PutResourceVersionUploadFileRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
+}