@easyedu/js-lsm-api 1.86.0 → 1.88.0

package/dist/apis/CertificateApi.js

@@ -22,17 +22,23 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.GetCertificatesStatusEnum = exports.GetCertificateConfigsScopeEnum = exports.CertificateApi = void 0;
+exports.GetCertificatesStatusEnum = exports.GetCertificateCsvExportStatusEnum = exports.GetCertificateConfigsScopeEnum = exports.CertificateApi = void 0;
 const runtime = require("../runtime");
+const BadgeIssuer_1 = require("../models/BadgeIssuer");
 const Certificate_1 = require("../models/Certificate");
+const CertificateArtifact_1 = require("../models/CertificateArtifact");
 const CertificateConfig_1 = require("../models/CertificateConfig");
 const CertificatePublic_1 = require("../models/CertificatePublic");
 const EffectiveCertificateConfig_1 = require("../models/EffectiveCertificateConfig");
 const GetCertificateConfigList_1 = require("../models/GetCertificateConfigList");
+const GetCertificateEventList_1 = require("../models/GetCertificateEventList");
 const GetCertificateList_1 = require("../models/GetCertificateList");
+const GetPublicBadgeCredentialStatus200Response_1 = require("../models/GetPublicBadgeCredentialStatus200Response");
 const PostCertificate_1 = require("../models/PostCertificate");
 const PostCertificateConfig_1 = require("../models/PostCertificateConfig");
+const PostCertificateLifecycleAction_1 = require("../models/PostCertificateLifecycleAction");
 const PostRevokeCertificate_1 = require("../models/PostRevokeCertificate");
+const PutBadgeIssuer_1 = require("../models/PutBadgeIssuer");
 const PutCertificateConfig_1 = require("../models/PutCertificateConfig");
 /**
  *
@@ -76,6 +82,41 @@ class CertificateApi extends runtime.BaseAPI {
             yield this.deleteCertificateConfigRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Creates request options for getBadgeIssuer without sending the request
+     */
+    getBadgeIssuerRequestOpts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/badge-issuer`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Get the selected portal Open Badges issuer
+     */
+    getBadgeIssuerRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getBadgeIssuerRequestOpts();
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, BadgeIssuer_1.BadgeIssuerFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Get the selected portal Open Badges issuer
+     */
+    getBadgeIssuer(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getBadgeIssuerRaw(initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for getCertificate without sending the request
      */
@@ -195,6 +236,95 @@ class CertificateApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for getCertificateCsvExport without sending the request
+     */
+    getCertificateCsvExportRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            if (requestParameters['userId'] != null) {
+                queryParameters['user_id'] = requestParameters['userId'];
+            }
+            if (requestParameters['courseId'] != null) {
+                queryParameters['course_id'] = requestParameters['courseId'];
+            }
+            if (requestParameters['status'] != null) {
+                queryParameters['status'] = requestParameters['status'];
+            }
+            if (requestParameters['issuedAfter'] != null) {
+                queryParameters['issued_after'] = requestParameters['issuedAfter'];
+            }
+            if (requestParameters['issuedBefore'] != null) {
+                queryParameters['issued_before'] = requestParameters['issuedBefore'];
+            }
+            const headerParameters = {};
+            let urlPath = `/certificates/export`;
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Export filtered certificate records as CSV
+     */
+    getCertificateCsvExportRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getCertificateCsvExportRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.BlobApiResponse(response);
+        });
+    }
+    /**
+     * Export filtered certificate records as CSV
+     */
+    getCertificateCsvExport() {
+        return __awaiter(this, arguments, void 0, function* (requestParameters = {}, initOverrides) {
+            const response = yield this.getCertificateCsvExportRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getCertificateEvents without sending the request
+     */
+    getCertificateEventsRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['certificateId'] == null) {
+                throw new runtime.RequiredError('certificateId', 'Required parameter "certificateId" was null or undefined when calling getCertificateEvents().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificates/{certificateId}/events`;
+            urlPath = urlPath.replace('{certificateId}', encodeURIComponent(String(requestParameters['certificateId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * List immutable lifecycle events for a certificate
+     */
+    getCertificateEventsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getCertificateEventsRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, GetCertificateEventList_1.GetCertificateEventListFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * List immutable lifecycle events for a certificate
+     */
+    getCertificateEvents(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getCertificateEventsRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for getCertificatePdf without sending the request
      */
@@ -367,6 +497,397 @@ class CertificateApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for getPublicBadgeAchievement without sending the request
+     */
+    getPublicBadgeAchievementRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['achievementId'] == null) {
+                throw new runtime.RequiredError('achievementId', 'Required parameter "achievementId" was null or undefined when calling getPublicBadgeAchievement().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/public/badge-achievements/{achievementId}`;
+            urlPath = urlPath.replace('{achievementId}', encodeURIComponent(String(requestParameters['achievementId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Get a hosted Open Badges Achievement
+     */
+    getPublicBadgeAchievementRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPublicBadgeAchievementRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response);
+        });
+    }
+    /**
+     * Get a hosted Open Badges Achievement
+     */
+    getPublicBadgeAchievement(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPublicBadgeAchievementRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPublicBadgeAchievementImage without sending the request
+     */
+    getPublicBadgeAchievementImageRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['achievementId'] == null) {
+                throw new runtime.RequiredError('achievementId', 'Required parameter "achievementId" was null or undefined when calling getPublicBadgeAchievementImage().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/public/badge-achievements/{achievementId}/image`;
+            urlPath = urlPath.replace('{achievementId}', encodeURIComponent(String(requestParameters['achievementId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Get a validated square PNG badge image
+     */
+    getPublicBadgeAchievementImageRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPublicBadgeAchievementImageRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.BlobApiResponse(response);
+        });
+    }
+    /**
+     * Get a validated square PNG badge image
+     */
+    getPublicBadgeAchievementImage(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPublicBadgeAchievementImageRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPublicBadgeCredential without sending the request
+     */
+    getPublicBadgeCredentialRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['credentialId'] == null) {
+                throw new runtime.RequiredError('credentialId', 'Required parameter "credentialId" was null or undefined when calling getPublicBadgeCredential().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/public/badge-credentials/{credentialId}`;
+            urlPath = urlPath.replace('{credentialId}', encodeURIComponent(String(requestParameters['credentialId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Download an Open Badges 3.0 VC-JWT
+     */
+    getPublicBadgeCredentialRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPublicBadgeCredentialRequestOpts(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);
+            }
+        });
+    }
+    /**
+     * Download an Open Badges 3.0 VC-JWT
+     */
+    getPublicBadgeCredential(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPublicBadgeCredentialRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPublicBadgeCredentialDocument without sending the request
+     */
+    getPublicBadgeCredentialDocumentRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['credentialId'] == null) {
+                throw new runtime.RequiredError('credentialId', 'Required parameter "credentialId" was null or undefined when calling getPublicBadgeCredentialDocument().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/public/badge-credentials/{credentialId}/document`;
+            urlPath = urlPath.replace('{credentialId}', encodeURIComponent(String(requestParameters['credentialId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Read the signed Open Badges credential document
+     */
+    getPublicBadgeCredentialDocumentRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPublicBadgeCredentialDocumentRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response);
+        });
+    }
+    /**
+     * Read the signed Open Badges credential document
+     */
+    getPublicBadgeCredentialDocument(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPublicBadgeCredentialDocumentRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPublicBadgeCredentialStatus without sending the request
+     */
+    getPublicBadgeCredentialStatusRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['credentialId'] == null) {
+                throw new runtime.RequiredError('credentialId', 'Required parameter "credentialId" was null or undefined when calling getPublicBadgeCredentialStatus().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/public/badge-credentials/{credentialId}/status`;
+            urlPath = urlPath.replace('{credentialId}', encodeURIComponent(String(requestParameters['credentialId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Get mutable hosted status without changing the signed credential
+     */
+    getPublicBadgeCredentialStatusRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPublicBadgeCredentialStatusRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, GetPublicBadgeCredentialStatus200Response_1.GetPublicBadgeCredentialStatus200ResponseFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Get mutable hosted status without changing the signed credential
+     */
+    getPublicBadgeCredentialStatus(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPublicBadgeCredentialStatusRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPublicBadgeIssuer without sending the request
+     */
+    getPublicBadgeIssuerRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['portalId'] == null) {
+                throw new runtime.RequiredError('portalId', 'Required parameter "portalId" was null or undefined when calling getPublicBadgeIssuer().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/public/badge-issuers/{portalId}`;
+            urlPath = urlPath.replace('{portalId}', encodeURIComponent(String(requestParameters['portalId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Get an Open Badges issuer profile
+     */
+    getPublicBadgeIssuerRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPublicBadgeIssuerRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response);
+        });
+    }
+    /**
+     * Get an Open Badges issuer profile
+     */
+    getPublicBadgeIssuer(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPublicBadgeIssuerRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPublicBadgeIssuerDidDocument without sending the request
+     */
+    getPublicBadgeIssuerDidDocumentRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['portalId'] == null) {
+                throw new runtime.RequiredError('portalId', 'Required parameter "portalId" was null or undefined when calling getPublicBadgeIssuerDidDocument().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/public/badge-issuers/{portalId}/did.json`;
+            urlPath = urlPath.replace('{portalId}', encodeURIComponent(String(requestParameters['portalId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Get the portal-specific did:web document and retained public keys
+     */
+    getPublicBadgeIssuerDidDocumentRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPublicBadgeIssuerDidDocumentRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response);
+        });
+    }
+    /**
+     * Get the portal-specific did:web document and retained public keys
+     */
+    getPublicBadgeIssuerDidDocument(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPublicBadgeIssuerDidDocumentRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for getPublicCertificatePdf without sending the request
+     */
+    getPublicCertificatePdfRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['certificateId'] == null) {
+                throw new runtime.RequiredError('certificateId', 'Required parameter "certificateId" was null or undefined when calling getPublicCertificatePdf().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/public/certificates/{certificateId}/pdf`;
+            urlPath = urlPath.replace('{certificateId}', encodeURIComponent(String(requestParameters['certificateId'])));
+            return {
+                path: urlPath,
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Download an immutable public certificate PDF
+     */
+    getPublicCertificatePdfRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.getPublicCertificatePdfRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.BlobApiResponse(response);
+        });
+    }
+    /**
+     * Download an immutable public certificate PDF
+     */
+    getPublicCertificatePdf(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getPublicCertificatePdfRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postBadgeIssuerKeyRotate without sending the request
+     */
+    postBadgeIssuerKeyRotateRequestOpts() {
+        return __awaiter(this, void 0, void 0, function* () {
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/badge-issuer/keys/rotate`;
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Generate and activate a new KMS-wrapped portal signing key
+     */
+    postBadgeIssuerKeyRotateRaw(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postBadgeIssuerKeyRotateRequestOpts();
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, BadgeIssuer_1.BadgeIssuerFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Generate and activate a new KMS-wrapped portal signing key
+     */
+    postBadgeIssuerKeyRotate(initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postBadgeIssuerKeyRotateRaw(initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateArtifactRetry without sending the request
+     */
+    postCertificateArtifactRetryRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['certificateId'] == null) {
+                throw new runtime.RequiredError('certificateId', 'Required parameter "certificateId" was null or undefined when calling postCertificateArtifactRetry().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            let urlPath = `/certificates/{certificateId}/artifacts/retry`;
+            urlPath = urlPath.replace('{certificateId}', encodeURIComponent(String(requestParameters['certificateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            };
+        });
+    }
+    /**
+     * Retry failed certificate artifact generation
+     */
+    postCertificateArtifactRetryRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateArtifactRetryRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, CertificateArtifact_1.CertificateArtifactFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Retry failed certificate artifact generation
+     */
+    postCertificateArtifactRetry(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateArtifactRetryRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for postCertificateConfig without sending the request
      */
@@ -407,6 +928,97 @@ class CertificateApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for postCertificateRenew without sending the request
+     */
+    postCertificateRenewRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['certificateId'] == null) {
+                throw new runtime.RequiredError('certificateId', 'Required parameter "certificateId" was null or undefined when calling postCertificateRenew().');
+            }
+            if (requestParameters['postCertificateLifecycleAction'] == null) {
+                throw new runtime.RequiredError('postCertificateLifecycleAction', 'Required parameter "postCertificateLifecycleAction" was null or undefined when calling postCertificateRenew().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/certificates/{certificateId}/renew`;
+            urlPath = urlPath.replace('{certificateId}', encodeURIComponent(String(requestParameters['certificateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, PostCertificateLifecycleAction_1.PostCertificateLifecycleActionToJSON)(requestParameters['postCertificateLifecycleAction']),
+            };
+        });
+    }
+    /**
+     * Manually renew an eligible certificate
+     */
+    postCertificateRenewRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateRenewRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, Certificate_1.CertificateFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Manually renew an eligible certificate
+     */
+    postCertificateRenew(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateRenewRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Creates request options for postCertificateReplace without sending the request
+     */
+    postCertificateReplaceRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['certificateId'] == null) {
+                throw new runtime.RequiredError('certificateId', 'Required parameter "certificateId" was null or undefined when calling postCertificateReplace().');
+            }
+            if (requestParameters['postCertificateLifecycleAction'] == null) {
+                throw new runtime.RequiredError('postCertificateLifecycleAction', 'Required parameter "postCertificateLifecycleAction" was null or undefined when calling postCertificateReplace().');
+            }
+            const queryParameters = {};
+            if (requestParameters['correction'] != null) {
+                queryParameters['correction'] = requestParameters['correction'];
+            }
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/certificates/{certificateId}/replace`;
+            urlPath = urlPath.replace('{certificateId}', encodeURIComponent(String(requestParameters['certificateId'])));
+            return {
+                path: urlPath,
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, PostCertificateLifecycleAction_1.PostCertificateLifecycleActionToJSON)(requestParameters['postCertificateLifecycleAction']),
+            };
+        });
+    }
+    /**
+     * Replace or correct an issued certificate
+     */
+    postCertificateReplaceRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.postCertificateReplaceRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, Certificate_1.CertificateFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Replace or correct an issued certificate
+     */
+    postCertificateReplace(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.postCertificateReplaceRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for postCourseCertificate without sending the request
      */
@@ -495,6 +1107,46 @@ class CertificateApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Creates request options for putBadgeIssuer without sending the request
+     */
+    putBadgeIssuerRequestOpts(requestParameters) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters['putBadgeIssuer'] == null) {
+                throw new runtime.RequiredError('putBadgeIssuer', 'Required parameter "putBadgeIssuer" was null or undefined when calling putBadgeIssuer().');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            let urlPath = `/badge-issuer`;
+            return {
+                path: urlPath,
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: (0, PutBadgeIssuer_1.PutBadgeIssuerToJSON)(requestParameters['putBadgeIssuer']),
+            };
+        });
+    }
+    /**
+     * Create or update the selected portal Open Badges issuer
+     */
+    putBadgeIssuerRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const requestOptions = yield this.putBadgeIssuerRequestOpts(requestParameters);
+            const response = yield this.request(requestOptions, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => (0, BadgeIssuer_1.BadgeIssuerFromJSON)(jsonValue));
+        });
+    }
+    /**
+     * Create or update the selected portal Open Badges issuer
+     */
+    putBadgeIssuer(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.putBadgeIssuerRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Creates request options for putCertificateConfig without sending the request
      */
@@ -587,10 +1239,19 @@ exports.GetCertificateConfigsScopeEnum = {
     Portal: 'portal',
     Course: 'course'
 };
+/**
+ * @export
+ */
+exports.GetCertificateCsvExportStatusEnum = {
+    Active: 'active',
+    Revoked: 'revoked',
+    Superseded: 'superseded'
+};
 /**
  * @export
  */
 exports.GetCertificatesStatusEnum = {
     Active: 'active',
-    Revoked: 'revoked'
+    Revoked: 'revoked',
+    Superseded: 'superseded'
 };