@dynamic-labs/sdk-api 0.0.389 → 0.0.391

package/src/apis/SDKApi.js

@@ -50,6 +50,17 @@ import { InitPasskeyRecoveryRequestToJSON } from '../models/InitPasskeyRecoveryR
 import { InitPasskeyRecoveryResponseFromJSON } from '../models/InitPasskeyRecoveryResponse.js';
 import '../models/InviteStatusEnum.js';
 import { JwksResponseFromJSON } from '../models/JwksResponse.js';
+import { MFAAuthRecoveryDevicePostRequestToJSON } from '../models/MFAAuthRecoveryDevicePostRequest.js';
+import { MFAAuthResponseFromJSON } from '../models/MFAAuthResponse.js';
+import { MFAAuthTotpDevicePostRequestToJSON } from '../models/MFAAuthTotpDevicePostRequest.js';
+import { MFADeviceFromJSON } from '../models/MFADevice.js';
+import '../models/MFADeviceType.js';
+import { MFAGetRecoveryCodesResponseFromJSON } from '../models/MFAGetRecoveryCodesResponse.js';
+import { MFAListDevicesResponseFromJSON } from '../models/MFAListDevicesResponse.js';
+import { MFARegenRecoveryCodesResponseFromJSON } from '../models/MFARegenRecoveryCodesResponse.js';
+import { MFARegisterTotpDeviceGetResponseFromJSON } from '../models/MFARegisterTotpDeviceGetResponse.js';
+import { MFARegisterTotpDevicePostRequestToJSON } from '../models/MFARegisterTotpDevicePostRequest.js';
+import { MFAUpdateDeviceRequestToJSON } from '../models/MFAUpdateDeviceRequest.js';
 import { NetworkConfigurationResponseFromJSON } from '../models/NetworkConfigurationResponse.js';
 import '../models/NextViewEnum.js';
 import { NonceResponseFromJSON } from '../models/NonceResponse.js';
@@ -91,6 +102,140 @@ import '../models/VisitorFilterableFieldsEnum.js';
  *
  */
 class SDKApi extends BaseAPI {
+    /**
+     * Upgrade JWT scope with valid MFA session
+     */
+    authMfaRecoveryRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling authMfaRecovery.');
+            }
+            if (requestParameters.mFAAuthRecoveryDevicePostRequest === null || requestParameters.mFAAuthRecoveryDevicePostRequest === undefined) {
+                throw new RequiredError('mFAAuthRecoveryDevicePostRequest', 'Required parameter requestParameters.mFAAuthRecoveryDevicePostRequest was null or undefined when calling authMfaRecovery.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/auth/recovery`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: MFAAuthRecoveryDevicePostRequestToJSON(requestParameters.mFAAuthRecoveryDevicePostRequest),
+            }, initOverrides);
+            return new JSONApiResponse(response, (jsonValue) => MFAAuthResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Upgrade JWT scope with valid MFA session
+     */
+    authMfaRecovery(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.authMfaRecoveryRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    authMfaRecoveryOptionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling authMfaRecoveryOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/auth/recovery`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    authMfaRecoveryOptions(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.authMfaRecoveryOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Upgrade JWT scope with valid MFA session
+     */
+    authMfaTotpDeviceRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling authMfaTotpDevice.');
+            }
+            if (requestParameters.mFAAuthTotpDevicePostRequest === null || requestParameters.mFAAuthTotpDevicePostRequest === undefined) {
+                throw new RequiredError('mFAAuthTotpDevicePostRequest', 'Required parameter requestParameters.mFAAuthTotpDevicePostRequest was null or undefined when calling authMfaTotpDevice.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/auth/totp`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: MFAAuthTotpDevicePostRequestToJSON(requestParameters.mFAAuthTotpDevicePostRequest),
+            }, initOverrides);
+            return new JSONApiResponse(response, (jsonValue) => MFAAuthResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Upgrade JWT scope with valid MFA session
+     */
+    authMfaTotpDevice(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.authMfaTotpDeviceRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    authMfaTotpDeviceOptionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling authMfaTotpDeviceOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/auth/totp`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    authMfaTotpDeviceOptions(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.authMfaTotpDeviceOptionsRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Claim a pregenerated embedded wallet
      */
@@ -329,6 +474,41 @@ class SDKApi extends BaseAPI {
             yield this.createEmbeddedWalletsOptionsRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Generate new recovery codes for user
+     */
+    createNewRecoveryCodesRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling createNewRecoveryCodes.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/recovery`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new JSONApiResponse(response, (jsonValue) => MFARegenRecoveryCodesResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Generate new recovery codes for user
+     */
+    createNewRecoveryCodes(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createNewRecoveryCodesRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Initialize sms verification process
      */
@@ -423,6 +603,43 @@ class SDKApi extends BaseAPI {
             yield this.createVisitRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Delete a device (if not default device)
+     */
+    deleteMfaDeviceRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling deleteMfaDevice.');
+            }
+            if (requestParameters.mfaDeviceId === null || requestParameters.mfaDeviceId === undefined) {
+                throw new RequiredError('mfaDeviceId', 'Required parameter requestParameters.mfaDeviceId was null or undefined when calling deleteMfaDevice.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/{mfaDeviceId}`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"mfaDeviceId"}}`, encodeURIComponent(String(requestParameters.mfaDeviceId))),
+                method: 'DELETE',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new VoidApiResponse(response);
+        });
+    }
+    /**
+     * Delete a device (if not default device)
+     */
+    deleteMfaDevice(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.deleteMfaDeviceRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Options call for this endpoint
      */
@@ -1022,6 +1239,74 @@ class SDKApi extends BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Get the current user\'s MFA by device id
+     */
+    getMfaDeviceRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getMfaDevice.');
+            }
+            if (requestParameters.mfaDeviceId === null || requestParameters.mfaDeviceId === undefined) {
+                throw new RequiredError('mfaDeviceId', 'Required parameter requestParameters.mfaDeviceId was null or undefined when calling getMfaDevice.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/{mfaDeviceId}`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"mfaDeviceId"}}`, encodeURIComponent(String(requestParameters.mfaDeviceId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new JSONApiResponse(response, (jsonValue) => MFADeviceFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get the current user\'s MFA by device id
+     */
+    getMfaDevice(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getMfaDeviceRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    getMfaDeviceOptionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getMfaDeviceOptions.');
+            }
+            if (requestParameters.mfaDeviceId === null || requestParameters.mfaDeviceId === undefined) {
+                throw new RequiredError('mfaDeviceId', 'Required parameter requestParameters.mfaDeviceId was null or undefined when calling getMfaDeviceOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/{mfaDeviceId}`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"mfaDeviceId"}}`, encodeURIComponent(String(requestParameters.mfaDeviceId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    getMfaDeviceOptions(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.getMfaDeviceOptionsRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Find the configuration for the enabled networks associated to an environment
      */
@@ -1078,6 +1363,41 @@ class SDKApi extends BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Get recovery codes
+     */
+    getRecoveryCodesRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getRecoveryCodes.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/recovery`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new JSONApiResponse(response, (jsonValue) => MFAGetRecoveryCodesResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get recovery codes
+     */
+    getRecoveryCodes(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getRecoveryCodesRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Find the configuration for the enabled onramps associated to an environment
      * Configuration for enabled onramps
@@ -1126,6 +1446,41 @@ class SDKApi extends BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Get the current user\'s MFA Devices
+     */
+    getUserMfaDevicesRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getUserMfaDevices.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new JSONApiResponse(response, (jsonValue) => MFAListDevicesResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get the current user\'s MFA Devices
+     */
+    getUserMfaDevices(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.getUserMfaDevicesRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Gets passkey data associated with a user
      */
@@ -1272,6 +1627,33 @@ class SDKApi extends BaseAPI {
             yield this.jwksOptionsRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Options call for this endpoint
+     */
+    listMfaDevicesOptionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling listMfaDevicesOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    listMfaDevicesOptions(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.listMfaDevicesOptionsRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Update SDK settings for a specific environment
      */
@@ -2100,6 +2482,33 @@ class SDKApi extends BaseAPI {
             yield this.publishEventRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Options call for this endpoint
+     */
+    recoveryCodesOptionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling recoveryCodesOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/recovery`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    recoveryCodesOptions(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.recoveryCodesOptionsRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Endpoint to refresh the JWT auth token using the current valid JWT auth token in the authorization header
      */
@@ -2162,6 +2571,108 @@ class SDKApi extends BaseAPI {
             yield this.refreshOptionsRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Register a new TOTP MFA device and get Totp Secret
+     */
+    registerTotpMfaDeviceRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling registerTotpMfaDevice.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/register/totp`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'GET',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new JSONApiResponse(response, (jsonValue) => MFARegisterTotpDeviceGetResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Register a new TOTP MFA device and get Totp Secret
+     */
+    registerTotpMfaDevice(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.registerTotpMfaDeviceRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    registerTotpMfaDeviceOptionsRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling registerTotpMfaDeviceOptions.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/register/totp`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'OPTIONS',
+                headers: headerParameters,
+                query: queryParameters,
+            }, initOverrides);
+            return new VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    registerTotpMfaDeviceOptions(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.registerTotpMfaDeviceOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Verify TOTP MFA device
+     */
+    registerTotpMfaDeviceVerifyRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling registerTotpMfaDeviceVerify.');
+            }
+            if (requestParameters.mFARegisterTotpDevicePostRequest === null || requestParameters.mFARegisterTotpDevicePostRequest === undefined) {
+                throw new RequiredError('mFARegisterTotpDevicePostRequest', 'Required parameter requestParameters.mFARegisterTotpDevicePostRequest was null or undefined when calling registerTotpMfaDeviceVerify.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/register/totp`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))),
+                method: 'POST',
+                headers: headerParameters,
+                query: queryParameters,
+                body: MFARegisterTotpDevicePostRequestToJSON(requestParameters.mFARegisterTotpDevicePostRequest),
+            }, initOverrides);
+            return new JSONApiResponse(response, (jsonValue) => MFADeviceFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Verify TOTP MFA device
+     */
+    registerTotpMfaDeviceVerify(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const response = yield this.registerTotpMfaDeviceVerifyRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Send new code for email verification
      */
@@ -2595,6 +3106,45 @@ class SDKApi extends BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Update a device
+     */
+    updateUserMfaDeviceRaw(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling updateUserMfaDevice.');
+            }
+            if (requestParameters.mfaDeviceId === null || requestParameters.mfaDeviceId === undefined) {
+                throw new RequiredError('mfaDeviceId', 'Required parameter requestParameters.mfaDeviceId was null or undefined when calling updateUserMfaDevice.');
+            }
+            const queryParameters = {};
+            const headerParameters = {};
+            headerParameters['Content-Type'] = 'application/json';
+            if (this.configuration && this.configuration.accessToken) {
+                const token = this.configuration.accessToken;
+                const tokenString = yield token("bearerAuth", []);
+                if (tokenString) {
+                    headerParameters["Authorization"] = `Bearer ${tokenString}`;
+                }
+            }
+            const response = yield this.request({
+                path: `/sdk/{environmentId}/users/mfa/{mfaDeviceId}`.replace(`{${"environmentId"}}`, encodeURIComponent(String(requestParameters.environmentId))).replace(`{${"mfaDeviceId"}}`, encodeURIComponent(String(requestParameters.mfaDeviceId))),
+                method: 'PUT',
+                headers: headerParameters,
+                query: queryParameters,
+                body: MFAUpdateDeviceRequestToJSON(requestParameters.mFAUpdateDeviceRequest),
+            }, initOverrides);
+            return new VoidApiResponse(response);
+        });
+    }
+    /**
+     * Update a device
+     */
+    updateUserMfaDevice(requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function* () {
+            yield this.updateUserMfaDeviceRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Options call for this endpoint
      */

package/src/apis/SDKViewsApi.cjs

@@ -34,6 +34,7 @@ require('../models/ExportStatusEnum.cjs');
 require('../models/GateRuleType.cjs');
 require('../models/HealthcheckStatus.cjs');
 require('../models/InviteStatusEnum.cjs');
+require('../models/MFADeviceType.cjs');
 require('../models/NextViewEnum.cjs');
 require('../models/OauthResultStatus.cjs');
 require('../models/WhenToImplementEnum.cjs');

package/src/apis/SDKViewsApi.js

@@ -30,6 +30,7 @@ import '../models/ExportStatusEnum.js';
 import '../models/GateRuleType.js';
 import '../models/HealthcheckStatus.js';
 import '../models/InviteStatusEnum.js';
+import '../models/MFADeviceType.js';
 import '../models/NextViewEnum.js';
 import '../models/OauthResultStatus.js';
 import '../models/WhenToImplementEnum.js';

package/src/apis/SessionsApi.cjs

@@ -36,6 +36,7 @@ require('../models/ExportStatusEnum.cjs');
 require('../models/GateRuleType.cjs');
 require('../models/HealthcheckStatus.cjs');
 require('../models/InviteStatusEnum.cjs');
+require('../models/MFADeviceType.cjs');
 require('../models/NextViewEnum.cjs');
 require('../models/OauthResultStatus.cjs');
 var Session = require('../models/Session.cjs');

package/src/apis/SessionsApi.js

@@ -32,6 +32,7 @@ import '../models/ExportStatusEnum.js';
 import '../models/GateRuleType.js';
 import '../models/HealthcheckStatus.js';
 import '../models/InviteStatusEnum.js';
+import '../models/MFADeviceType.js';
 import '../models/NextViewEnum.js';
 import '../models/OauthResultStatus.js';
 import { SessionFromJSON } from '../models/Session.js';

package/src/apis/SettingsApi.cjs

@@ -37,6 +37,7 @@ require('../models/ExportStatusEnum.cjs');
 require('../models/GateRuleType.cjs');
 require('../models/HealthcheckStatus.cjs');
 require('../models/InviteStatusEnum.cjs');
+require('../models/MFADeviceType.cjs');
 require('../models/NextViewEnum.cjs');
 require('../models/OauthResultStatus.cjs');
 require('../models/WhenToImplementEnum.cjs');