@easyedu/js-lsm-api 1.85.0 → 1.87.0

package/dist/esm/apis/CertificateTemplateApi.js

@@ -0,0 +1,1542 @@
+/* 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.
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import * as runtime from '../runtime';
+import { CertificateTemplateFromJSON, } from '../models/CertificateTemplate';
+import { CertificateTemplateVersionFromJSON, } from '../models/CertificateTemplateVersion';
+import { GetCertificateAssetUploadFromJSON, } from '../models/GetCertificateAssetUpload';
+import { GetCertificateTemplateListFromJSON, } from '../models/GetCertificateTemplateList';
+import { PostCertificateAssetCompleteToJSON, } from '../models/PostCertificateAssetComplete';
+import { PostCertificateAssetUploadToJSON, } from '../models/PostCertificateAssetUpload';
+import { PostCertificateTemplateToJSON, } from '../models/PostCertificateTemplate';
+import { PostCertificateTemplateCloneToJSON, } from '../models/PostCertificateTemplateClone';
+import { PostCertificateTemplatePreviewToJSON, } from '../models/PostCertificateTemplatePreview';
+import { PutCertificateTemplateToJSON, } from '../models/PutCertificateTemplate';
+import { PutCertificateTemplateDraftToJSON, } from '../models/PutCertificateTemplateDraft';
+/**
+ *
+ */
+export class CertificateTemplateApi extends runtime.BaseAPI {
+    /**
+     * Creates request options for deleteCertificateTemplateDraft without sending the request
+     */
+    deleteCertificateTemplateDraftRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling deleteCertificateTemplateDraft().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificate-templates/{templateId}/draft`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'DELETE',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Discard the current certificate design draft
+     */
+    deleteCertificateTemplateDraftRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.deleteCertificateTemplateDraftRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Discard the current certificate design draft
+     */
+    deleteCertificateTemplateDraft(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.deleteCertificateTemplateDraftRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Creates request options for deletePlatformCertificateTemplateDraft without sending the request
+     */
+    deletePlatformCertificateTemplateDraftRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling deletePlatformCertificateTemplateDraft().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/system/certificate-templates/{templateId}/draft`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'DELETE',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Discard a platform certificate design draft
+     */
+    deletePlatformCertificateTemplateDraftRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.deletePlatformCertificateTemplateDraftRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Discard a platform certificate design draft
+     */
+    deletePlatformCertificateTemplateDraft(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.deletePlatformCertificateTemplateDraftRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Creates request options for getCertificateAsset without sending the request
+     */
+    getCertificateAssetRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['assetId'] == null) {
+                throw new runtime.RequiredError('assetId', 'Required parameter "assetId" was null or undefined when calling getCertificateAsset().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificate-assets/{assetId}`;
+            urlPath = urlPath.replace('{assetId}', encodeURIComponent(String(requestParameters['assetId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Read a portal certificate asset for design editing
+     */
+    getCertificateAssetRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getCertificateAssetRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.BlobApiResponse(response);
+        });
+    }
+    /**
+     * Read a portal certificate asset for design editing
+     */
+    getCertificateAsset(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getCertificateAssetRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getCertificateTemplate without sending the request
+     */
+    getCertificateTemplateRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling getCertificateTemplate().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificate-templates/{templateId}`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Get a certificate design with draft and history
+     */
+    getCertificateTemplateRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getCertificateTemplateRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get a certificate design with draft and history
+     */
+    getCertificateTemplate(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getCertificateTemplateRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getCertificateTemplateList without sending the request
+     */
+    getCertificateTemplateListRequestOpts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificate-templates`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * List local and inherited certificate designs
+     */
+    getCertificateTemplateListRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getCertificateTemplateListRequestOpts();
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetCertificateTemplateListFromJSON(jsonValue));
+        });
+    }
+    /**
+     * List local and inherited certificate designs
+     */
+    getCertificateTemplateList(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getCertificateTemplateListRaw(initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getCertificateTemplateVersions without sending the request
+     */
+    getCertificateTemplateVersionsRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling getCertificateTemplateVersions().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificate-templates/{templateId}/versions`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * List certificate design version history
+     */
+    getCertificateTemplateVersionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getCertificateTemplateVersionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CertificateTemplateVersionFromJSON));
+        });
+    }
+    /**
+     * List certificate design version history
+     */
+    getCertificateTemplateVersions(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getCertificateTemplateVersionsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPlatformCertificateAsset without sending the request
+     */
+    getPlatformCertificateAssetRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['assetId'] == null) {
+                throw new runtime.RequiredError('assetId', 'Required parameter "assetId" was null or undefined when calling getPlatformCertificateAsset().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/system/certificate-assets/{assetId}`;
+            urlPath = urlPath.replace('{assetId}', encodeURIComponent(String(requestParameters['assetId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Read a platform certificate asset for design editing
+     */
+    getPlatformCertificateAssetRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPlatformCertificateAssetRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.BlobApiResponse(response);
+        });
+    }
+    /**
+     * Read a platform certificate asset for design editing
+     */
+    getPlatformCertificateAsset(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPlatformCertificateAssetRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPlatformCertificateTemplate without sending the request
+     */
+    getPlatformCertificateTemplateRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling getPlatformCertificateTemplate().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/system/certificate-templates/{templateId}`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Get a platform certificate design
+     */
+    getPlatformCertificateTemplateRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPlatformCertificateTemplateRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get a platform certificate design
+     */
+    getPlatformCertificateTemplate(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPlatformCertificateTemplateRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPlatformCertificateTemplateList without sending the request
+     */
+    getPlatformCertificateTemplateListRequestOpts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/system/certificate-templates`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * List platform certificate designs
+     */
+    getPlatformCertificateTemplateListRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPlatformCertificateTemplateListRequestOpts();
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetCertificateTemplateListFromJSON(jsonValue));
+        });
+    }
+    /**
+     * List platform certificate designs
+     */
+    getPlatformCertificateTemplateList(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPlatformCertificateTemplateListRaw(initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPlatformCertificateTemplateVersions without sending the request
+     */
+    getPlatformCertificateTemplateVersionsRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling getPlatformCertificateTemplateVersions().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/system/certificate-templates/{templateId}/versions`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * List platform certificate design version history
+     */
+    getPlatformCertificateTemplateVersionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPlatformCertificateTemplateVersionsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(CertificateTemplateVersionFromJSON));
+        });
+    }
+    /**
+     * List platform certificate design version history
+     */
+    getPlatformCertificateTemplateVersions(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPlatformCertificateTemplateVersionsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPublicCertificateAsset without sending the request
+     */
+    getPublicCertificateAssetRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['assetId'] == null) {
+                throw new runtime.RequiredError('assetId', 'Required parameter "assetId" was null or undefined when calling getPublicCertificateAsset().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/public/certificate-assets/{assetId}`;
+            urlPath = urlPath.replace('{assetId}', encodeURIComponent(String(requestParameters['assetId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Read a managed certificate or badge image
+     */
+    getPublicCertificateAssetRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPublicCertificateAssetRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.BlobApiResponse(response);
+        });
+    }
+    /**
+     * Read a managed certificate or badge image
+     */
+    getPublicCertificateAsset(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPublicCertificateAssetRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateAssetComplete without sending the request
+     */
+    postCertificateAssetCompleteRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['assetId'] == null) {
+                throw new runtime.RequiredError('assetId', 'Required parameter "assetId" was null or undefined when calling postCertificateAssetComplete().');
+            }
+            if (requestParameters['postCertificateAssetComplete'] == null) {
+                throw new runtime.RequiredError('postCertificateAssetComplete', 'Required parameter "postCertificateAssetComplete" was null or undefined when calling postCertificateAssetComplete().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/certificate-assets/{assetId}/complete`;
+            urlPath = urlPath.replace('{assetId}', encodeURIComponent(String(requestParameters['assetId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostCertificateAssetCompleteToJSON(requestParameters['postCertificateAssetComplete']),
+            };
+        });
+    }
+    /**
+     * Validate and complete a certificate image upload
+     */
+    postCertificateAssetCompleteRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateAssetCompleteRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetCertificateAssetUploadFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Validate and complete a certificate image upload
+     */
+    postCertificateAssetComplete(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateAssetCompleteRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateAssetUpload without sending the request
+     */
+    postCertificateAssetUploadRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['postCertificateAssetUpload'] == null) {
+                throw new runtime.RequiredError('postCertificateAssetUpload', 'Required parameter "postCertificateAssetUpload" was null or undefined when calling postCertificateAssetUpload().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/certificate-assets/uploads`;
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostCertificateAssetUploadToJSON(requestParameters['postCertificateAssetUpload']),
+            };
+        });
+    }
+    /**
+     * Create a portal certificate image upload
+     */
+    postCertificateAssetUploadRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateAssetUploadRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetCertificateAssetUploadFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Create a portal certificate image upload
+     */
+    postCertificateAssetUpload(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateAssetUploadRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateTemplate without sending the request
+     */
+    postCertificateTemplateRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['postCertificateTemplate'] == null) {
+                throw new runtime.RequiredError('postCertificateTemplate', 'Required parameter "postCertificateTemplate" was null or undefined when calling postCertificateTemplate().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/certificate-templates`;
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostCertificateTemplateToJSON(requestParameters['postCertificateTemplate']),
+            };
+        });
+    }
+    /**
+     * Create a portal certificate design and initial draft
+     */
+    postCertificateTemplateRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateTemplateRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Create a portal certificate design and initial draft
+     */
+    postCertificateTemplate(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateTemplateRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateTemplateArchive without sending the request
+     */
+    postCertificateTemplateArchiveRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postCertificateTemplateArchive().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificate-templates/{templateId}/archive`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Archive a local certificate design
+     */
+    postCertificateTemplateArchiveRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateTemplateArchiveRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Archive a local certificate design
+     */
+    postCertificateTemplateArchive(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateTemplateArchiveRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateTemplateClone without sending the request
+     */
+    postCertificateTemplateCloneRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postCertificateTemplateClone().');
+            }
+            if (requestParameters['postCertificateTemplateClone'] == null) {
+                throw new runtime.RequiredError('postCertificateTemplateClone', 'Required parameter "postCertificateTemplateClone" was null or undefined when calling postCertificateTemplateClone().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/certificate-templates/{templateId}/clone`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostCertificateTemplateCloneToJSON(requestParameters['postCertificateTemplateClone']),
+            };
+        });
+    }
+    /**
+     * Clone an inherited or local design into the selected portal
+     */
+    postCertificateTemplateCloneRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateTemplateCloneRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Clone an inherited or local design into the selected portal
+     */
+    postCertificateTemplateClone(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateTemplateCloneRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateTemplateDraft without sending the request
+     */
+    postCertificateTemplateDraftRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postCertificateTemplateDraft().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificate-templates/{templateId}/draft`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Create a draft from the active version
+     */
+    postCertificateTemplateDraftRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateTemplateDraftRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateVersionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Create a draft from the active version
+     */
+    postCertificateTemplateDraft(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateTemplateDraftRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateTemplateDraftPreview without sending the request
+     */
+    postCertificateTemplateDraftPreviewRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postCertificateTemplateDraftPreview().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificate-templates/{templateId}/draft/preview`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Canonically render the saved draft
+     */
+    postCertificateTemplateDraftPreviewRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateTemplateDraftPreviewRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.BlobApiResponse(response);
+        });
+    }
+    /**
+     * Canonically render the saved draft
+     */
+    postCertificateTemplateDraftPreview(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateTemplateDraftPreviewRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateTemplatePreview without sending the request
+     */
+    postCertificateTemplatePreviewRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postCertificateTemplatePreview().');
+            }
+            if (requestParameters['postCertificateTemplatePreview'] == null) {
+                throw new runtime.RequiredError('postCertificateTemplatePreview', 'Required parameter "postCertificateTemplatePreview" was null or undefined when calling postCertificateTemplatePreview().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/certificate-templates/{templateId}/preview`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostCertificateTemplatePreviewToJSON(requestParameters['postCertificateTemplatePreview']),
+            };
+        });
+    }
+    /**
+     * Canonically render an unsaved canvas document
+     */
+    postCertificateTemplatePreviewRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateTemplatePreviewRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.BlobApiResponse(response);
+        });
+    }
+    /**
+     * Canonically render an unsaved canvas document
+     */
+    postCertificateTemplatePreview(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateTemplatePreviewRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateTemplatePublish without sending the request
+     */
+    postCertificateTemplatePublishRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postCertificateTemplatePublish().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificate-templates/{templateId}/publish`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Publish and activate the current draft
+     */
+    postCertificateTemplatePublishRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateTemplatePublishRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateVersionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Publish and activate the current draft
+     */
+    postCertificateTemplatePublish(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateTemplatePublishRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateTemplateRestore without sending the request
+     */
+    postCertificateTemplateRestoreRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postCertificateTemplateRestore().');
+            }
+            if (requestParameters['versionId'] == null) {
+                throw new runtime.RequiredError('versionId', 'Required parameter "versionId" was null or undefined when calling postCertificateTemplateRestore().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificate-templates/{templateId}/versions/{versionId}/restore`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            urlPath = urlPath.replace('{versionId}', encodeURIComponent(String(requestParameters['versionId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Restore a historical version into a new draft
+     */
+    postCertificateTemplateRestoreRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateTemplateRestoreRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateVersionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Restore a historical version into a new draft
+     */
+    postCertificateTemplateRestore(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateTemplateRestoreRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postPlatformCertificateAssetComplete without sending the request
+     */
+    postPlatformCertificateAssetCompleteRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['assetId'] == null) {
+                throw new runtime.RequiredError('assetId', 'Required parameter "assetId" was null or undefined when calling postPlatformCertificateAssetComplete().');
+            }
+            if (requestParameters['postCertificateAssetComplete'] == null) {
+                throw new runtime.RequiredError('postCertificateAssetComplete', 'Required parameter "postCertificateAssetComplete" was null or undefined when calling postPlatformCertificateAssetComplete().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/system/certificate-assets/{assetId}/complete`;
+            urlPath = urlPath.replace('{assetId}', encodeURIComponent(String(requestParameters['assetId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostCertificateAssetCompleteToJSON(requestParameters['postCertificateAssetComplete']),
+            };
+        });
+    }
+    /**
+     * Complete a platform certificate image upload
+     */
+    postPlatformCertificateAssetCompleteRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postPlatformCertificateAssetCompleteRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetCertificateAssetUploadFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Complete a platform certificate image upload
+     */
+    postPlatformCertificateAssetComplete(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postPlatformCertificateAssetCompleteRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postPlatformCertificateAssetUpload without sending the request
+     */
+    postPlatformCertificateAssetUploadRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['postCertificateAssetUpload'] == null) {
+                throw new runtime.RequiredError('postCertificateAssetUpload', 'Required parameter "postCertificateAssetUpload" was null or undefined when calling postPlatformCertificateAssetUpload().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/system/certificate-assets/uploads`;
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostCertificateAssetUploadToJSON(requestParameters['postCertificateAssetUpload']),
+            };
+        });
+    }
+    /**
+     * Create a platform certificate image upload
+     */
+    postPlatformCertificateAssetUploadRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postPlatformCertificateAssetUploadRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => GetCertificateAssetUploadFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Create a platform certificate image upload
+     */
+    postPlatformCertificateAssetUpload(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postPlatformCertificateAssetUploadRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postPlatformCertificateTemplate without sending the request
+     */
+    postPlatformCertificateTemplateRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['postCertificateTemplate'] == null) {
+                throw new runtime.RequiredError('postCertificateTemplate', 'Required parameter "postCertificateTemplate" was null or undefined when calling postPlatformCertificateTemplate().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/system/certificate-templates`;
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostCertificateTemplateToJSON(requestParameters['postCertificateTemplate']),
+            };
+        });
+    }
+    /**
+     * Create a platform certificate design
+     */
+    postPlatformCertificateTemplateRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postPlatformCertificateTemplateRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Create a platform certificate design
+     */
+    postPlatformCertificateTemplate(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postPlatformCertificateTemplateRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postPlatformCertificateTemplateArchive without sending the request
+     */
+    postPlatformCertificateTemplateArchiveRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postPlatformCertificateTemplateArchive().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/system/certificate-templates/{templateId}/archive`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Archive a platform certificate design
+     */
+    postPlatformCertificateTemplateArchiveRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postPlatformCertificateTemplateArchiveRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Archive a platform certificate design
+     */
+    postPlatformCertificateTemplateArchive(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postPlatformCertificateTemplateArchiveRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postPlatformCertificateTemplateClone without sending the request
+     */
+    postPlatformCertificateTemplateCloneRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postPlatformCertificateTemplateClone().');
+            }
+            if (requestParameters['postCertificateTemplateClone'] == null) {
+                throw new runtime.RequiredError('postCertificateTemplateClone', 'Required parameter "postCertificateTemplateClone" was null or undefined when calling postPlatformCertificateTemplateClone().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/system/certificate-templates/{templateId}/clone`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostCertificateTemplateCloneToJSON(requestParameters['postCertificateTemplateClone']),
+            };
+        });
+    }
+    /**
+     * Clone a platform certificate design
+     */
+    postPlatformCertificateTemplateCloneRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postPlatformCertificateTemplateCloneRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Clone a platform certificate design
+     */
+    postPlatformCertificateTemplateClone(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postPlatformCertificateTemplateCloneRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postPlatformCertificateTemplateDraft without sending the request
+     */
+    postPlatformCertificateTemplateDraftRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postPlatformCertificateTemplateDraft().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/system/certificate-templates/{templateId}/draft`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Create a platform certificate design draft
+     */
+    postPlatformCertificateTemplateDraftRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postPlatformCertificateTemplateDraftRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateVersionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Create a platform certificate design draft
+     */
+    postPlatformCertificateTemplateDraft(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postPlatformCertificateTemplateDraftRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postPlatformCertificateTemplateDraftPreview without sending the request
+     */
+    postPlatformCertificateTemplateDraftPreviewRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postPlatformCertificateTemplateDraftPreview().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/system/certificate-templates/{templateId}/draft/preview`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Render the saved platform certificate design draft
+     */
+    postPlatformCertificateTemplateDraftPreviewRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postPlatformCertificateTemplateDraftPreviewRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.BlobApiResponse(response);
+        });
+    }
+    /**
+     * Render the saved platform certificate design draft
+     */
+    postPlatformCertificateTemplateDraftPreview(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postPlatformCertificateTemplateDraftPreviewRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postPlatformCertificateTemplatePreview without sending the request
+     */
+    postPlatformCertificateTemplatePreviewRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postPlatformCertificateTemplatePreview().');
+            }
+            if (requestParameters['postCertificateTemplatePreview'] == null) {
+                throw new runtime.RequiredError('postCertificateTemplatePreview', 'Required parameter "postCertificateTemplatePreview" was null or undefined when calling postPlatformCertificateTemplatePreview().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/system/certificate-templates/{templateId}/preview`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PostCertificateTemplatePreviewToJSON(requestParameters['postCertificateTemplatePreview']),
+            };
+        });
+    }
+    /**
+     * Render an unsaved platform certificate design
+     */
+    postPlatformCertificateTemplatePreviewRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postPlatformCertificateTemplatePreviewRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.BlobApiResponse(response);
+        });
+    }
+    /**
+     * Render an unsaved platform certificate design
+     */
+    postPlatformCertificateTemplatePreview(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postPlatformCertificateTemplatePreviewRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postPlatformCertificateTemplatePublish without sending the request
+     */
+    postPlatformCertificateTemplatePublishRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postPlatformCertificateTemplatePublish().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/system/certificate-templates/{templateId}/publish`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Publish a platform certificate design draft
+     */
+    postPlatformCertificateTemplatePublishRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postPlatformCertificateTemplatePublishRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateVersionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Publish a platform certificate design draft
+     */
+    postPlatformCertificateTemplatePublish(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postPlatformCertificateTemplatePublishRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postPlatformCertificateTemplateRestore without sending the request
+     */
+    postPlatformCertificateTemplateRestoreRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling postPlatformCertificateTemplateRestore().');
+            }
+            if (requestParameters['versionId'] == null) {
+                throw new runtime.RequiredError('versionId', 'Required parameter "versionId" was null or undefined when calling postPlatformCertificateTemplateRestore().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/system/certificate-templates/{templateId}/versions/{versionId}/restore`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            urlPath = urlPath.replace('{versionId}', encodeURIComponent(String(requestParameters['versionId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Restore a platform certificate design version as a draft
+     */
+    postPlatformCertificateTemplateRestoreRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postPlatformCertificateTemplateRestoreRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateVersionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Restore a platform certificate design version as a draft
+     */
+    postPlatformCertificateTemplateRestore(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postPlatformCertificateTemplateRestoreRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for putCertificateAssetFile without sending the request
+     */
+    putCertificateAssetFileRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['assetId'] == null) {
+                throw new runtime.RequiredError('assetId', 'Required parameter "assetId" was null or undefined when calling putCertificateAssetFile().');
+            }
+            if (requestParameters['body'] == null) {
+                throw new runtime.RequiredError('body', 'Required parameter "body" was null or undefined when calling putCertificateAssetFile().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'image/png';
+            let urlPath = `/certificate-assets/{assetId}/file`;
+            urlPath = urlPath.replace('{assetId}', encodeURIComponent(String(requestParameters['assetId'])));
+            return {
+                path: urlPath,
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: requestParameters['body'],
+            };
+        });
+    }
+    /**
+     * Upload certificate image bytes
+     */
+    putCertificateAssetFileRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.putCertificateAssetFileRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Upload certificate image bytes
+     */
+    putCertificateAssetFile(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.putCertificateAssetFileRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Creates request options for putCertificateTemplate without sending the request
+     */
+    putCertificateTemplateRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling putCertificateTemplate().');
+            }
+            if (requestParameters['putCertificateTemplate'] == null) {
+                throw new runtime.RequiredError('putCertificateTemplate', 'Required parameter "putCertificateTemplate" was null or undefined when calling putCertificateTemplate().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/certificate-templates/{templateId}`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PutCertificateTemplateToJSON(requestParameters['putCertificateTemplate']),
+            };
+        });
+    }
+    /**
+     * Update local certificate design metadata
+     */
+    putCertificateTemplateRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.putCertificateTemplateRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Update local certificate design metadata
+     */
+    putCertificateTemplate(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.putCertificateTemplateRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for putCertificateTemplateDraft without sending the request
+     */
+    putCertificateTemplateDraftRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling putCertificateTemplateDraft().');
+            }
+            if (requestParameters['putCertificateTemplateDraft'] == null) {
+                throw new runtime.RequiredError('putCertificateTemplateDraft', 'Required parameter "putCertificateTemplateDraft" was null or undefined when calling putCertificateTemplateDraft().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/certificate-templates/{templateId}/draft`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PutCertificateTemplateDraftToJSON(requestParameters['putCertificateTemplateDraft']),
+            };
+        });
+    }
+    /**
+     * Update a certificate design draft
+     */
+    putCertificateTemplateDraftRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.putCertificateTemplateDraftRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateVersionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Update a certificate design draft
+     */
+    putCertificateTemplateDraft(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.putCertificateTemplateDraftRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for putPlatformCertificateAssetFile without sending the request
+     */
+    putPlatformCertificateAssetFileRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['assetId'] == null) {
+                throw new runtime.RequiredError('assetId', 'Required parameter "assetId" was null or undefined when calling putPlatformCertificateAssetFile().');
+            }
+            if (requestParameters['body'] == null) {
+                throw new runtime.RequiredError('body', 'Required parameter "body" was null or undefined when calling putPlatformCertificateAssetFile().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'image/png';
+            let urlPath = `/system/certificate-assets/{assetId}/file`;
+            urlPath = urlPath.replace('{assetId}', encodeURIComponent(String(requestParameters['assetId'])));
+            return {
+                path: urlPath,
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: requestParameters['body'],
+            };
+        });
+    }
+    /**
+     * Upload platform certificate image bytes
+     */
+    putPlatformCertificateAssetFileRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.putPlatformCertificateAssetFileRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Upload platform certificate image bytes
+     */
+    putPlatformCertificateAssetFile(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.putPlatformCertificateAssetFileRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Creates request options for putPlatformCertificateTemplate without sending the request
+     */
+    putPlatformCertificateTemplateRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling putPlatformCertificateTemplate().');
+            }
+            if (requestParameters['putCertificateTemplate'] == null) {
+                throw new runtime.RequiredError('putCertificateTemplate', 'Required parameter "putCertificateTemplate" was null or undefined when calling putPlatformCertificateTemplate().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/system/certificate-templates/{templateId}`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PutCertificateTemplateToJSON(requestParameters['putCertificateTemplate']),
+            };
+        });
+    }
+    /**
+     * Update platform certificate design metadata
+     */
+    putPlatformCertificateTemplateRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.putPlatformCertificateTemplateRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Update platform certificate design metadata
+     */
+    putPlatformCertificateTemplate(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.putPlatformCertificateTemplateRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for putPlatformCertificateTemplateDraft without sending the request
+     */
+    putPlatformCertificateTemplateDraftRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['templateId'] == null) {
+                throw new runtime.RequiredError('templateId', 'Required parameter "templateId" was null or undefined when calling putPlatformCertificateTemplateDraft().');
+            }
+            if (requestParameters['putCertificateTemplateDraft'] == null) {
+                throw new runtime.RequiredError('putCertificateTemplateDraft', 'Required parameter "putCertificateTemplateDraft" was null or undefined when calling putPlatformCertificateTemplateDraft().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/system/certificate-templates/{templateId}/draft`;
+            urlPath = urlPath.replace('{templateId}', encodeURIComponent(String(requestParameters['templateId'])));
+            return {
+                path: urlPath,
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: PutCertificateTemplateDraftToJSON(requestParameters['putCertificateTemplateDraft']),
+            };
+        });
+    }
+    /**
+     * Update a platform certificate design draft
+     */
+    putPlatformCertificateTemplateDraftRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.putPlatformCertificateTemplateDraftRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => CertificateTemplateVersionFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Update a platform certificate design draft
+     */
+    putPlatformCertificateTemplateDraft(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.putPlatformCertificateTemplateDraftRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+}