@easyedu/js-lsm-api 1.86.0 → 1.87.0

package/dist/esm/apis/CertificateApi.js

@@ -21,15 +21,21 @@ var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, ge
     });
 };
 import * as runtime from '../runtime';
+import { BadgeIssuerFromJSON, } from '../models/BadgeIssuer';
 import { CertificateFromJSON, } from '../models/Certificate';
+import { CertificateArtifactFromJSON, } from '../models/CertificateArtifact';
 import { CertificateConfigFromJSON, } from '../models/CertificateConfig';
 import { CertificatePublicFromJSON, } from '../models/CertificatePublic';
 import { EffectiveCertificateConfigFromJSON, } from '../models/EffectiveCertificateConfig';
 import { GetCertificateConfigListFromJSON, } from '../models/GetCertificateConfigList';
+import { GetCertificateEventListFromJSON, } from '../models/GetCertificateEventList';
 import { GetCertificateListFromJSON, } from '../models/GetCertificateList';
+import { GetPublicBadgeCredentialStatus200ResponseFromJSON, } from '../models/GetPublicBadgeCredentialStatus200Response';
 import { PostCertificateToJSON, } from '../models/PostCertificate';
 import { PostCertificateConfigToJSON, } from '../models/PostCertificateConfig';
+import { PostCertificateLifecycleActionToJSON, } from '../models/PostCertificateLifecycleAction';
 import { PostRevokeCertificateToJSON, } from '../models/PostRevokeCertificate';
+import { PutBadgeIssuerToJSON, } from '../models/PutBadgeIssuer';
 import { PutCertificateConfigToJSON, } from '../models/PutCertificateConfig';
 /**
  *
@@ -73,6 +79,41 @@ export 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) => 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
      */
@@ -192,6 +233,95 @@ export 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) => 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
      */
@@ -364,6 +494,397 @@ export 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) => 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) => 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) => 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
      */
@@ -404,6 +925,97 @@ export 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: 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) => 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: 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) => 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
      */
@@ -492,6 +1104,46 @@ export 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: 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) => 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
      */
@@ -583,10 +1235,19 @@ export const GetCertificateConfigsScopeEnum = {
     Portal: 'portal',
     Course: 'course'
 };
+/**
+ * @export
+ */
+export const GetCertificateCsvExportStatusEnum = {
+    Active: 'active',
+    Revoked: 'revoked',
+    Superseded: 'superseded'
+};
 /**
  * @export
  */
 export const GetCertificatesStatusEnum = {
     Active: 'active',
-    Revoked: 'revoked'
+    Revoked: 'revoked',
+    Superseded: 'superseded'
 };