@easyedu/js-lsm-api 1.85.0 → 1.87.0

package/src/apis/CertificateApi.ts

@@ -13,11 +13,26 @@
  */
 
 import * as runtime from '../runtime';
+import {
+    type ArtifactConflict,
+    ArtifactConflictFromJSON,
+    ArtifactConflictToJSON,
+} from '../models/ArtifactConflict';
+import {
+    type BadgeIssuer,
+    BadgeIssuerFromJSON,
+    BadgeIssuerToJSON,
+} from '../models/BadgeIssuer';
 import {
     type Certificate,
     CertificateFromJSON,
     CertificateToJSON,
 } from '../models/Certificate';
+import {
+    type CertificateArtifact,
+    CertificateArtifactFromJSON,
+    CertificateArtifactToJSON,
+} from '../models/CertificateArtifact';
 import {
     type CertificateConfig,
     CertificateConfigFromJSON,
@@ -38,11 +53,21 @@ import {
     GetCertificateConfigListFromJSON,
     GetCertificateConfigListToJSON,
 } from '../models/GetCertificateConfigList';
+import {
+    type GetCertificateEventList,
+    GetCertificateEventListFromJSON,
+    GetCertificateEventListToJSON,
+} from '../models/GetCertificateEventList';
 import {
     type GetCertificateList,
     GetCertificateListFromJSON,
     GetCertificateListToJSON,
 } from '../models/GetCertificateList';
+import {
+    type GetPublicBadgeCredentialStatus200Response,
+    GetPublicBadgeCredentialStatus200ResponseFromJSON,
+    GetPublicBadgeCredentialStatus200ResponseToJSON,
+} from '../models/GetPublicBadgeCredentialStatus200Response';
 import {
     type PostCertificate,
     PostCertificateFromJSON,
@@ -53,11 +78,21 @@ import {
     PostCertificateConfigFromJSON,
     PostCertificateConfigToJSON,
 } from '../models/PostCertificateConfig';
+import {
+    type PostCertificateLifecycleAction,
+    PostCertificateLifecycleActionFromJSON,
+    PostCertificateLifecycleActionToJSON,
+} from '../models/PostCertificateLifecycleAction';
 import {
     type PostRevokeCertificate,
     PostRevokeCertificateFromJSON,
     PostRevokeCertificateToJSON,
 } from '../models/PostRevokeCertificate';
+import {
+    type PutBadgeIssuer,
+    PutBadgeIssuerFromJSON,
+    PutBadgeIssuerToJSON,
+} from '../models/PutBadgeIssuer';
 import {
     type PutCertificateConfig,
     PutCertificateConfigFromJSON,
@@ -81,6 +116,18 @@ export interface GetCertificateConfigsRequest {
     scope?: GetCertificateConfigsScopeEnum;
 }
 
+export interface GetCertificateCsvExportRequest {
+    userId?: string;
+    courseId?: string;
+    status?: GetCertificateCsvExportStatusEnum;
+    issuedAfter?: number;
+    issuedBefore?: number;
+}
+
+export interface GetCertificateEventsRequest {
+    certificateId: string;
+}
+
 export interface GetCertificatePdfRequest {
     certificateId: string;
 }
@@ -100,10 +147,57 @@ export interface GetEffectiveCertificateConfigRequest {
     courseId: string;
 }
 
+export interface GetPublicBadgeAchievementRequest {
+    achievementId: string;
+}
+
+export interface GetPublicBadgeAchievementImageRequest {
+    achievementId: string;
+}
+
+export interface GetPublicBadgeCredentialRequest {
+    credentialId: string;
+}
+
+export interface GetPublicBadgeCredentialDocumentRequest {
+    credentialId: string;
+}
+
+export interface GetPublicBadgeCredentialStatusRequest {
+    credentialId: string;
+}
+
+export interface GetPublicBadgeIssuerRequest {
+    portalId: string;
+}
+
+export interface GetPublicBadgeIssuerDidDocumentRequest {
+    portalId: string;
+}
+
+export interface GetPublicCertificatePdfRequest {
+    certificateId: string;
+}
+
+export interface PostCertificateArtifactRetryRequest {
+    certificateId: string;
+}
+
 export interface PostCertificateConfigRequest {
     postCertificateConfig: PostCertificateConfig;
 }
 
+export interface PostCertificateRenewRequest {
+    certificateId: string;
+    postCertificateLifecycleAction: PostCertificateLifecycleAction;
+}
+
+export interface PostCertificateReplaceRequest {
+    certificateId: string;
+    postCertificateLifecycleAction: PostCertificateLifecycleAction;
+    correction?: boolean;
+}
+
 export interface PostCourseCertificateRequest {
     courseId: string;
     postCertificate: PostCertificate;
@@ -114,6 +208,10 @@ export interface PostRevokeCertificateRequest {
     postRevokeCertificate: PostRevokeCertificate;
 }
 
+export interface PutBadgeIssuerRequest {
+    putBadgeIssuer: PutBadgeIssuer;
+}
+
 export interface PutCertificateConfigRequest {
     configId: string;
     putCertificateConfig: PutCertificateConfig;
@@ -172,6 +270,43 @@ export class CertificateApi extends runtime.BaseAPI {
         await this.deleteCertificateConfigRaw(requestParameters, initOverrides);
     }
 
+    /**
+     * Creates request options for getBadgeIssuer without sending the request
+     */
+    async getBadgeIssuerRequestOpts(): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/badge-issuer`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Get the selected portal Open Badges issuer
+     */
+    async getBadgeIssuerRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BadgeIssuer>> {
+        const requestOptions = await this.getBadgeIssuerRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => BadgeIssuerFromJSON(jsonValue));
+    }
+
+    /**
+     * Get the selected portal Open Badges issuer
+     */
+    async getBadgeIssuer(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BadgeIssuer> {
+        const response = await this.getBadgeIssuerRaw(initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for getCertificate without sending the request
      */
@@ -307,6 +442,108 @@ export class CertificateApi extends runtime.BaseAPI {
         return await response.value();
     }
 
+    /**
+     * Creates request options for getCertificateCsvExport without sending the request
+     */
+    async getCertificateCsvExportRequestOpts(requestParameters: GetCertificateCsvExportRequest): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        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: runtime.HTTPHeaders = {};
+
+
+        let urlPath = `/certificates/export`;
+
+        return {
+            path: urlPath,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        };
+    }
+
+    /**
+     * Export filtered certificate records as CSV
+     */
+    async getCertificateCsvExportRaw(requestParameters: GetCertificateCsvExportRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blob>> {
+        const requestOptions = await this.getCertificateCsvExportRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.BlobApiResponse(response);
+    }
+
+    /**
+     * Export filtered certificate records as CSV
+     */
+    async getCertificateCsvExport(requestParameters: GetCertificateCsvExportRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blob> {
+        const response = await this.getCertificateCsvExportRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getCertificateEvents without sending the request
+     */
+    async getCertificateEventsRequestOpts(requestParameters: GetCertificateEventsRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['certificateId'] == null) {
+            throw new runtime.RequiredError(
+                'certificateId',
+                'Required parameter "certificateId" was null or undefined when calling getCertificateEvents().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        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
+     */
+    async getCertificateEventsRaw(requestParameters: GetCertificateEventsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetCertificateEventList>> {
+        const requestOptions = await this.getCertificateEventsRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetCertificateEventListFromJSON(jsonValue));
+    }
+
+    /**
+     * List immutable lifecycle events for a certificate
+     */
+    async getCertificateEvents(requestParameters: GetCertificateEventsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetCertificateEventList> {
+        const response = await this.getCertificateEventsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * Creates request options for getCertificatePdf without sending the request
      */
@@ -504,13 +741,13 @@ export class CertificateApi extends runtime.BaseAPI {
     }
 
     /**
-     * Creates request options for postCertificateConfig without sending the request
+     * Creates request options for getPublicBadgeAchievement without sending the request
      */
-    async postCertificateConfigRequestOpts(requestParameters: PostCertificateConfigRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['postCertificateConfig'] == null) {
+    async getPublicBadgeAchievementRequestOpts(requestParameters: GetPublicBadgeAchievementRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['achievementId'] == null) {
             throw new runtime.RequiredError(
-                'postCertificateConfig',
-                'Required parameter "postCertificateConfig" was null or undefined when calling postCertificateConfig().'
+                'achievementId',
+                'Required parameter "achievementId" was null or undefined when calling getPublicBadgeAchievement().'
             );
         }
 
@@ -518,53 +755,44 @@ export class CertificateApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
 
-        let urlPath = `/certificate-configs`;
+        let urlPath = `/public/badge-achievements/{achievementId}`;
+        urlPath = urlPath.replace('{achievementId}', encodeURIComponent(String(requestParameters['achievementId'])));
 
         return {
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: PostCertificateConfigToJSON(requestParameters['postCertificateConfig']),
         };
     }
 
     /**
-     * Create a certificate config
+     * Get a hosted Open Badges Achievement
      */
-    async postCertificateConfigRaw(requestParameters: PostCertificateConfigRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CertificateConfig>> {
-        const requestOptions = await this.postCertificateConfigRequestOpts(requestParameters);
+    async getPublicBadgeAchievementRaw(requestParameters: GetPublicBadgeAchievementRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<{ [key: string]: any; }>> {
+        const requestOptions = await this.getPublicBadgeAchievementRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateConfigFromJSON(jsonValue));
+        return new runtime.JSONApiResponse<any>(response);
     }
 
     /**
-     * Create a certificate config
+     * Get a hosted Open Badges Achievement
      */
-    async postCertificateConfig(requestParameters: PostCertificateConfigRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CertificateConfig> {
-        const response = await this.postCertificateConfigRaw(requestParameters, initOverrides);
+    async getPublicBadgeAchievement(requestParameters: GetPublicBadgeAchievementRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{ [key: string]: any; }> {
+        const response = await this.getPublicBadgeAchievementRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Creates request options for postCourseCertificate without sending the request
+     * Creates request options for getPublicBadgeAchievementImage without sending the request
      */
-    async postCourseCertificateRequestOpts(requestParameters: PostCourseCertificateRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['courseId'] == null) {
-            throw new runtime.RequiredError(
-                'courseId',
-                'Required parameter "courseId" was null or undefined when calling postCourseCertificate().'
-            );
-        }
-
-        if (requestParameters['postCertificate'] == null) {
+    async getPublicBadgeAchievementImageRequestOpts(requestParameters: GetPublicBadgeAchievementImageRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['achievementId'] == null) {
             throw new runtime.RequiredError(
-                'postCertificate',
-                'Required parameter "postCertificate" was null or undefined when calling postCourseCertificate().'
+                'achievementId',
+                'Required parameter "achievementId" was null or undefined when calling getPublicBadgeAchievementImage().'
             );
         }
 
@@ -572,54 +800,44 @@ export class CertificateApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
 
-        let urlPath = `/courses/{courseId}/certificates`;
-        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+        let urlPath = `/public/badge-achievements/{achievementId}/image`;
+        urlPath = urlPath.replace('{achievementId}', encodeURIComponent(String(requestParameters['achievementId'])));
 
         return {
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: PostCertificateToJSON(requestParameters['postCertificate']),
         };
     }
 
     /**
-     * Manually issue a certificate for a course
+     * Get a validated square PNG badge image
      */
-    async postCourseCertificateRaw(requestParameters: PostCourseCertificateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Certificate>> {
-        const requestOptions = await this.postCourseCertificateRequestOpts(requestParameters);
+    async getPublicBadgeAchievementImageRaw(requestParameters: GetPublicBadgeAchievementImageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blob>> {
+        const requestOptions = await this.getPublicBadgeAchievementImageRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateFromJSON(jsonValue));
+        return new runtime.BlobApiResponse(response);
     }
 
     /**
-     * Manually issue a certificate for a course
+     * Get a validated square PNG badge image
      */
-    async postCourseCertificate(requestParameters: PostCourseCertificateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Certificate> {
-        const response = await this.postCourseCertificateRaw(requestParameters, initOverrides);
+    async getPublicBadgeAchievementImage(requestParameters: GetPublicBadgeAchievementImageRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blob> {
+        const response = await this.getPublicBadgeAchievementImageRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Creates request options for postRevokeCertificate without sending the request
+     * Creates request options for getPublicBadgeCredential without sending the request
      */
-    async postRevokeCertificateRequestOpts(requestParameters: PostRevokeCertificateRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['certificateId'] == null) {
-            throw new runtime.RequiredError(
-                'certificateId',
-                'Required parameter "certificateId" was null or undefined when calling postRevokeCertificate().'
-            );
-        }
-
-        if (requestParameters['postRevokeCertificate'] == null) {
+    async getPublicBadgeCredentialRequestOpts(requestParameters: GetPublicBadgeCredentialRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['credentialId'] == null) {
             throw new runtime.RequiredError(
-                'postRevokeCertificate',
-                'Required parameter "postRevokeCertificate" was null or undefined when calling postRevokeCertificate().'
+                'credentialId',
+                'Required parameter "credentialId" was null or undefined when calling getPublicBadgeCredential().'
             );
         }
 
@@ -627,54 +845,48 @@ export class CertificateApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
 
-        let urlPath = `/certificates/{certificateId}/revoke`;
-        urlPath = urlPath.replace('{certificateId}', encodeURIComponent(String(requestParameters['certificateId'])));
+        let urlPath = `/public/badge-credentials/{credentialId}`;
+        urlPath = urlPath.replace('{credentialId}', encodeURIComponent(String(requestParameters['credentialId'])));
 
         return {
             path: urlPath,
-            method: 'POST',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: PostRevokeCertificateToJSON(requestParameters['postRevokeCertificate']),
         };
     }
 
     /**
-     * Revoke a certificate
+     * Download an Open Badges 3.0 VC-JWT
      */
-    async postRevokeCertificateRaw(requestParameters: PostRevokeCertificateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Certificate>> {
-        const requestOptions = await this.postRevokeCertificateRequestOpts(requestParameters);
+    async getPublicBadgeCredentialRaw(requestParameters: GetPublicBadgeCredentialRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<string>> {
+        const requestOptions = await this.getPublicBadgeCredentialRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateFromJSON(jsonValue));
+        if (this.isJsonMime(response.headers.get('content-type'))) {
+            return new runtime.JSONApiResponse<string>(response);
+        } else {
+            return new runtime.TextApiResponse(response) as any;
+        }
     }
 
     /**
-     * Revoke a certificate
+     * Download an Open Badges 3.0 VC-JWT
      */
-    async postRevokeCertificate(requestParameters: PostRevokeCertificateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Certificate> {
-        const response = await this.postRevokeCertificateRaw(requestParameters, initOverrides);
+    async getPublicBadgeCredential(requestParameters: GetPublicBadgeCredentialRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<string> {
+        const response = await this.getPublicBadgeCredentialRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Creates request options for putCertificateConfig without sending the request
+     * Creates request options for getPublicBadgeCredentialDocument without sending the request
      */
-    async putCertificateConfigRequestOpts(requestParameters: PutCertificateConfigRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['configId'] == null) {
-            throw new runtime.RequiredError(
-                'configId',
-                'Required parameter "configId" was null or undefined when calling putCertificateConfig().'
-            );
-        }
-
-        if (requestParameters['putCertificateConfig'] == null) {
+    async getPublicBadgeCredentialDocumentRequestOpts(requestParameters: GetPublicBadgeCredentialDocumentRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['credentialId'] == null) {
             throw new runtime.RequiredError(
-                'putCertificateConfig',
-                'Required parameter "putCertificateConfig" was null or undefined when calling putCertificateConfig().'
+                'credentialId',
+                'Required parameter "credentialId" was null or undefined when calling getPublicBadgeCredentialDocument().'
             );
         }
 
@@ -682,47 +894,679 @@ export class CertificateApi extends runtime.BaseAPI {
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        headerParameters['Content-Type'] = 'application/json';
-
 
-        let urlPath = `/certificate-configs/{configId}`;
-        urlPath = urlPath.replace('{configId}', encodeURIComponent(String(requestParameters['configId'])));
+        let urlPath = `/public/badge-credentials/{credentialId}/document`;
+        urlPath = urlPath.replace('{credentialId}', encodeURIComponent(String(requestParameters['credentialId'])));
 
         return {
             path: urlPath,
-            method: 'PUT',
+            method: 'GET',
             headers: headerParameters,
             query: queryParameters,
-            body: PutCertificateConfigToJSON(requestParameters['putCertificateConfig']),
         };
     }
 
     /**
-     * Update a certificate config
+     * Read the signed Open Badges credential document
      */
-    async putCertificateConfigRaw(requestParameters: PutCertificateConfigRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CertificateConfig>> {
-        const requestOptions = await this.putCertificateConfigRequestOpts(requestParameters);
+    async getPublicBadgeCredentialDocumentRaw(requestParameters: GetPublicBadgeCredentialDocumentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<{ [key: string]: any; }>> {
+        const requestOptions = await this.getPublicBadgeCredentialDocumentRequestOpts(requestParameters);
         const response = await this.request(requestOptions, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateConfigFromJSON(jsonValue));
+        return new runtime.JSONApiResponse<any>(response);
     }
 
     /**
-     * Update a certificate config
+     * Read the signed Open Badges credential document
      */
-    async putCertificateConfig(requestParameters: PutCertificateConfigRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CertificateConfig> {
-        const response = await this.putCertificateConfigRaw(requestParameters, initOverrides);
+    async getPublicBadgeCredentialDocument(requestParameters: GetPublicBadgeCredentialDocumentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{ [key: string]: any; }> {
+        const response = await this.getPublicBadgeCredentialDocumentRaw(requestParameters, initOverrides);
         return await response.value();
     }
 
     /**
-     * Creates request options for verifyCertificate without sending the request
+     * Creates request options for getPublicBadgeCredentialStatus without sending the request
      */
-    async verifyCertificateRequestOpts(requestParameters: VerifyCertificateRequest): Promise<runtime.RequestOpts> {
-        if (requestParameters['certificateId'] == null) {
+    async getPublicBadgeCredentialStatusRequestOpts(requestParameters: GetPublicBadgeCredentialStatusRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['credentialId'] == null) {
             throw new runtime.RequiredError(
-                'certificateId',
-                'Required parameter "certificateId" was null or undefined when calling verifyCertificate().'
+                'credentialId',
+                'Required parameter "credentialId" was null or undefined when calling getPublicBadgeCredentialStatus().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        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
+     */
+    async getPublicBadgeCredentialStatusRaw(requestParameters: GetPublicBadgeCredentialStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<GetPublicBadgeCredentialStatus200Response>> {
+        const requestOptions = await this.getPublicBadgeCredentialStatusRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => GetPublicBadgeCredentialStatus200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Get mutable hosted status without changing the signed credential
+     */
+    async getPublicBadgeCredentialStatus(requestParameters: GetPublicBadgeCredentialStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<GetPublicBadgeCredentialStatus200Response> {
+        const response = await this.getPublicBadgeCredentialStatusRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getPublicBadgeIssuer without sending the request
+     */
+    async getPublicBadgeIssuerRequestOpts(requestParameters: GetPublicBadgeIssuerRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['portalId'] == null) {
+            throw new runtime.RequiredError(
+                'portalId',
+                'Required parameter "portalId" was null or undefined when calling getPublicBadgeIssuer().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        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
+     */
+    async getPublicBadgeIssuerRaw(requestParameters: GetPublicBadgeIssuerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<{ [key: string]: any; }>> {
+        const requestOptions = await this.getPublicBadgeIssuerRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get an Open Badges issuer profile
+     */
+    async getPublicBadgeIssuer(requestParameters: GetPublicBadgeIssuerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{ [key: string]: any; }> {
+        const response = await this.getPublicBadgeIssuerRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getPublicBadgeIssuerDidDocument without sending the request
+     */
+    async getPublicBadgeIssuerDidDocumentRequestOpts(requestParameters: GetPublicBadgeIssuerDidDocumentRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['portalId'] == null) {
+            throw new runtime.RequiredError(
+                'portalId',
+                'Required parameter "portalId" was null or undefined when calling getPublicBadgeIssuerDidDocument().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        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
+     */
+    async getPublicBadgeIssuerDidDocumentRaw(requestParameters: GetPublicBadgeIssuerDidDocumentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<{ [key: string]: any; }>> {
+        const requestOptions = await this.getPublicBadgeIssuerDidDocumentRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse<any>(response);
+    }
+
+    /**
+     * Get the portal-specific did:web document and retained public keys
+     */
+    async getPublicBadgeIssuerDidDocument(requestParameters: GetPublicBadgeIssuerDidDocumentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<{ [key: string]: any; }> {
+        const response = await this.getPublicBadgeIssuerDidDocumentRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for getPublicCertificatePdf without sending the request
+     */
+    async getPublicCertificatePdfRequestOpts(requestParameters: GetPublicCertificatePdfRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['certificateId'] == null) {
+            throw new runtime.RequiredError(
+                'certificateId',
+                'Required parameter "certificateId" was null or undefined when calling getPublicCertificatePdf().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        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
+     */
+    async getPublicCertificatePdfRaw(requestParameters: GetPublicCertificatePdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Blob>> {
+        const requestOptions = await this.getPublicCertificatePdfRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.BlobApiResponse(response);
+    }
+
+    /**
+     * Download an immutable public certificate PDF
+     */
+    async getPublicCertificatePdf(requestParameters: GetPublicCertificatePdfRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Blob> {
+        const response = await this.getPublicCertificatePdfRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postBadgeIssuerKeyRotate without sending the request
+     */
+    async postBadgeIssuerKeyRotateRequestOpts(): Promise<runtime.RequestOpts> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        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
+     */
+    async postBadgeIssuerKeyRotateRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BadgeIssuer>> {
+        const requestOptions = await this.postBadgeIssuerKeyRotateRequestOpts();
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => BadgeIssuerFromJSON(jsonValue));
+    }
+
+    /**
+     * Generate and activate a new KMS-wrapped portal signing key
+     */
+    async postBadgeIssuerKeyRotate(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BadgeIssuer> {
+        const response = await this.postBadgeIssuerKeyRotateRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postCertificateArtifactRetry without sending the request
+     */
+    async postCertificateArtifactRetryRequestOpts(requestParameters: PostCertificateArtifactRetryRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['certificateId'] == null) {
+            throw new runtime.RequiredError(
+                'certificateId',
+                'Required parameter "certificateId" was null or undefined when calling postCertificateArtifactRetry().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+
+        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
+     */
+    async postCertificateArtifactRetryRaw(requestParameters: PostCertificateArtifactRetryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CertificateArtifact>> {
+        const requestOptions = await this.postCertificateArtifactRetryRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateArtifactFromJSON(jsonValue));
+    }
+
+    /**
+     * Retry failed certificate artifact generation
+     */
+    async postCertificateArtifactRetry(requestParameters: PostCertificateArtifactRetryRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CertificateArtifact> {
+        const response = await this.postCertificateArtifactRetryRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postCertificateConfig without sending the request
+     */
+    async postCertificateConfigRequestOpts(requestParameters: PostCertificateConfigRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['postCertificateConfig'] == null) {
+            throw new runtime.RequiredError(
+                'postCertificateConfig',
+                'Required parameter "postCertificateConfig" was null or undefined when calling postCertificateConfig().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/certificate-configs`;
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostCertificateConfigToJSON(requestParameters['postCertificateConfig']),
+        };
+    }
+
+    /**
+     * Create a certificate config
+     */
+    async postCertificateConfigRaw(requestParameters: PostCertificateConfigRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CertificateConfig>> {
+        const requestOptions = await this.postCertificateConfigRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateConfigFromJSON(jsonValue));
+    }
+
+    /**
+     * Create a certificate config
+     */
+    async postCertificateConfig(requestParameters: PostCertificateConfigRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CertificateConfig> {
+        const response = await this.postCertificateConfigRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postCertificateRenew without sending the request
+     */
+    async postCertificateRenewRequestOpts(requestParameters: PostCertificateRenewRequest): Promise<runtime.RequestOpts> {
+        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: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        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
+     */
+    async postCertificateRenewRaw(requestParameters: PostCertificateRenewRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Certificate>> {
+        const requestOptions = await this.postCertificateRenewRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateFromJSON(jsonValue));
+    }
+
+    /**
+     * Manually renew an eligible certificate
+     */
+    async postCertificateRenew(requestParameters: PostCertificateRenewRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Certificate> {
+        const response = await this.postCertificateRenewRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postCertificateReplace without sending the request
+     */
+    async postCertificateReplaceRequestOpts(requestParameters: PostCertificateReplaceRequest): Promise<runtime.RequestOpts> {
+        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: any = {};
+
+        if (requestParameters['correction'] != null) {
+            queryParameters['correction'] = requestParameters['correction'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        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
+     */
+    async postCertificateReplaceRaw(requestParameters: PostCertificateReplaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Certificate>> {
+        const requestOptions = await this.postCertificateReplaceRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateFromJSON(jsonValue));
+    }
+
+    /**
+     * Replace or correct an issued certificate
+     */
+    async postCertificateReplace(requestParameters: PostCertificateReplaceRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Certificate> {
+        const response = await this.postCertificateReplaceRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postCourseCertificate without sending the request
+     */
+    async postCourseCertificateRequestOpts(requestParameters: PostCourseCertificateRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['courseId'] == null) {
+            throw new runtime.RequiredError(
+                'courseId',
+                'Required parameter "courseId" was null or undefined when calling postCourseCertificate().'
+            );
+        }
+
+        if (requestParameters['postCertificate'] == null) {
+            throw new runtime.RequiredError(
+                'postCertificate',
+                'Required parameter "postCertificate" was null or undefined when calling postCourseCertificate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/courses/{courseId}/certificates`;
+        urlPath = urlPath.replace('{courseId}', encodeURIComponent(String(requestParameters['courseId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostCertificateToJSON(requestParameters['postCertificate']),
+        };
+    }
+
+    /**
+     * Manually issue a certificate for a course
+     */
+    async postCourseCertificateRaw(requestParameters: PostCourseCertificateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Certificate>> {
+        const requestOptions = await this.postCourseCertificateRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateFromJSON(jsonValue));
+    }
+
+    /**
+     * Manually issue a certificate for a course
+     */
+    async postCourseCertificate(requestParameters: PostCourseCertificateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Certificate> {
+        const response = await this.postCourseCertificateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for postRevokeCertificate without sending the request
+     */
+    async postRevokeCertificateRequestOpts(requestParameters: PostRevokeCertificateRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['certificateId'] == null) {
+            throw new runtime.RequiredError(
+                'certificateId',
+                'Required parameter "certificateId" was null or undefined when calling postRevokeCertificate().'
+            );
+        }
+
+        if (requestParameters['postRevokeCertificate'] == null) {
+            throw new runtime.RequiredError(
+                'postRevokeCertificate',
+                'Required parameter "postRevokeCertificate" was null or undefined when calling postRevokeCertificate().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/certificates/{certificateId}/revoke`;
+        urlPath = urlPath.replace('{certificateId}', encodeURIComponent(String(requestParameters['certificateId'])));
+
+        return {
+            path: urlPath,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PostRevokeCertificateToJSON(requestParameters['postRevokeCertificate']),
+        };
+    }
+
+    /**
+     * Revoke a certificate
+     */
+    async postRevokeCertificateRaw(requestParameters: PostRevokeCertificateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<Certificate>> {
+        const requestOptions = await this.postRevokeCertificateRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateFromJSON(jsonValue));
+    }
+
+    /**
+     * Revoke a certificate
+     */
+    async postRevokeCertificate(requestParameters: PostRevokeCertificateRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<Certificate> {
+        const response = await this.postRevokeCertificateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for putBadgeIssuer without sending the request
+     */
+    async putBadgeIssuerRequestOpts(requestParameters: PutBadgeIssuerRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['putBadgeIssuer'] == null) {
+            throw new runtime.RequiredError(
+                'putBadgeIssuer',
+                'Required parameter "putBadgeIssuer" was null or undefined when calling putBadgeIssuer().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        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
+     */
+    async putBadgeIssuerRaw(requestParameters: PutBadgeIssuerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<BadgeIssuer>> {
+        const requestOptions = await this.putBadgeIssuerRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => BadgeIssuerFromJSON(jsonValue));
+    }
+
+    /**
+     * Create or update the selected portal Open Badges issuer
+     */
+    async putBadgeIssuer(requestParameters: PutBadgeIssuerRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<BadgeIssuer> {
+        const response = await this.putBadgeIssuerRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for putCertificateConfig without sending the request
+     */
+    async putCertificateConfigRequestOpts(requestParameters: PutCertificateConfigRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['configId'] == null) {
+            throw new runtime.RequiredError(
+                'configId',
+                'Required parameter "configId" was null or undefined when calling putCertificateConfig().'
+            );
+        }
+
+        if (requestParameters['putCertificateConfig'] == null) {
+            throw new runtime.RequiredError(
+                'putCertificateConfig',
+                'Required parameter "putCertificateConfig" was null or undefined when calling putCertificateConfig().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+
+        let urlPath = `/certificate-configs/{configId}`;
+        urlPath = urlPath.replace('{configId}', encodeURIComponent(String(requestParameters['configId'])));
+
+        return {
+            path: urlPath,
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: PutCertificateConfigToJSON(requestParameters['putCertificateConfig']),
+        };
+    }
+
+    /**
+     * Update a certificate config
+     */
+    async putCertificateConfigRaw(requestParameters: PutCertificateConfigRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<CertificateConfig>> {
+        const requestOptions = await this.putCertificateConfigRequestOpts(requestParameters);
+        const response = await this.request(requestOptions, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => CertificateConfigFromJSON(jsonValue));
+    }
+
+    /**
+     * Update a certificate config
+     */
+    async putCertificateConfig(requestParameters: PutCertificateConfigRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<CertificateConfig> {
+        const response = await this.putCertificateConfigRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Creates request options for verifyCertificate without sending the request
+     */
+    async verifyCertificateRequestOpts(requestParameters: VerifyCertificateRequest): Promise<runtime.RequestOpts> {
+        if (requestParameters['certificateId'] == null) {
+            throw new runtime.RequiredError(
+                'certificateId',
+                'Required parameter "certificateId" was null or undefined when calling verifyCertificate().'
             );
         }
 
@@ -770,11 +1614,21 @@ export const GetCertificateConfigsScopeEnum = {
     Course: 'course'
 } as const;
 export type GetCertificateConfigsScopeEnum = typeof GetCertificateConfigsScopeEnum[keyof typeof GetCertificateConfigsScopeEnum];
+/**
+ * @export
+ */
+export const GetCertificateCsvExportStatusEnum = {
+    Active: 'active',
+    Revoked: 'revoked',
+    Superseded: 'superseded'
+} as const;
+export type GetCertificateCsvExportStatusEnum = typeof GetCertificateCsvExportStatusEnum[keyof typeof GetCertificateCsvExportStatusEnum];
 /**
  * @export
  */
 export const GetCertificatesStatusEnum = {
     Active: 'active',
-    Revoked: 'revoked'
+    Revoked: 'revoked',
+    Superseded: 'superseded'
 } as const;
 export type GetCertificatesStatusEnum = typeof GetCertificatesStatusEnum[keyof typeof GetCertificatesStatusEnum];