@dynamic-labs/sdk-api 0.0.390 → 0.0.392

package/src/apis/SDKApi.cjs

@@ -54,6 +54,17 @@ var InitPasskeyRecoveryRequest = require('../models/InitPasskeyRecoveryRequest.c
 var InitPasskeyRecoveryResponse = require('../models/InitPasskeyRecoveryResponse.cjs');
 require('../models/InviteStatusEnum.cjs');
 var JwksResponse = require('../models/JwksResponse.cjs');
+var MFAAuthRecoveryDevicePostRequest = require('../models/MFAAuthRecoveryDevicePostRequest.cjs');
+var MFAAuthResponse = require('../models/MFAAuthResponse.cjs');
+var MFAAuthTotpDevicePostRequest = require('../models/MFAAuthTotpDevicePostRequest.cjs');
+var MFADevice = require('../models/MFADevice.cjs');
+require('../models/MFADeviceType.cjs');
+var MFAGetRecoveryCodesResponse = require('../models/MFAGetRecoveryCodesResponse.cjs');
+var MFAListDevicesResponse = require('../models/MFAListDevicesResponse.cjs');
+var MFARegenRecoveryCodesResponse = require('../models/MFARegenRecoveryCodesResponse.cjs');
+var MFARegisterTotpDeviceGetResponse = require('../models/MFARegisterTotpDeviceGetResponse.cjs');
+var MFARegisterTotpDevicePostRequest = require('../models/MFARegisterTotpDevicePostRequest.cjs');
+var MFAUpdateDeviceRequest = require('../models/MFAUpdateDeviceRequest.cjs');
 var NetworkConfigurationResponse = require('../models/NetworkConfigurationResponse.cjs');
 require('../models/NextViewEnum.cjs');
 var NonceResponse = require('../models/NonceResponse.cjs');
@@ -95,6 +106,140 @@ require('../models/VisitorFilterableFieldsEnum.cjs');
  *
  */
 class SDKApi extends runtime.BaseAPI {
+    /**
+     * Upgrade JWT scope with valid MFA session
+     */
+    authMfaRecoveryRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling authMfaRecovery.');
+            }
+            if (requestParameters.mFAAuthRecoveryDevicePostRequest === null || requestParameters.mFAAuthRecoveryDevicePostRequest === undefined) {
+                throw new runtime.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: MFAAuthRecoveryDevicePostRequest.MFAAuthRecoveryDevicePostRequestToJSON(requestParameters.mFAAuthRecoveryDevicePostRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => MFAAuthResponse.MFAAuthResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Upgrade JWT scope with valid MFA session
+     */
+    authMfaRecovery(requestParameters, initOverrides) {
+        return _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.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 runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    authMfaRecoveryOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.authMfaRecoveryOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Upgrade JWT scope with valid MFA session
+     */
+    authMfaTotpDeviceRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling authMfaTotpDevice.');
+            }
+            if (requestParameters.mFAAuthTotpDevicePostRequest === null || requestParameters.mFAAuthTotpDevicePostRequest === undefined) {
+                throw new runtime.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: MFAAuthTotpDevicePostRequest.MFAAuthTotpDevicePostRequestToJSON(requestParameters.mFAAuthTotpDevicePostRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => MFAAuthResponse.MFAAuthResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Upgrade JWT scope with valid MFA session
+     */
+    authMfaTotpDevice(requestParameters, initOverrides) {
+        return _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.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 runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    authMfaTotpDeviceOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.authMfaTotpDeviceOptionsRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Claim a pregenerated embedded wallet
      */
@@ -333,6 +478,41 @@ class SDKApi extends runtime.BaseAPI {
             yield this.createEmbeddedWalletsOptionsRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Generate new recovery codes for user
+     */
+    createNewRecoveryCodesRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.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 runtime.JSONApiResponse(response, (jsonValue) => MFARegenRecoveryCodesResponse.MFARegenRecoveryCodesResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Generate new recovery codes for user
+     */
+    createNewRecoveryCodes(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.createNewRecoveryCodesRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Initialize sms verification process
      */
@@ -427,6 +607,43 @@ class SDKApi extends runtime.BaseAPI {
             yield this.createVisitRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Delete a device (if not default device)
+     */
+    deleteMfaDeviceRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling deleteMfaDevice.');
+            }
+            if (requestParameters.mfaDeviceId === null || requestParameters.mfaDeviceId === undefined) {
+                throw new runtime.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 runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Delete a device (if not default device)
+     */
+    deleteMfaDevice(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.deleteMfaDeviceRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Options call for this endpoint
      */
@@ -1026,6 +1243,74 @@ class SDKApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Get the current user\'s MFA by device id
+     */
+    getMfaDeviceRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getMfaDevice.');
+            }
+            if (requestParameters.mfaDeviceId === null || requestParameters.mfaDeviceId === undefined) {
+                throw new runtime.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 runtime.JSONApiResponse(response, (jsonValue) => MFADevice.MFADeviceFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get the current user\'s MFA by device id
+     */
+    getMfaDevice(requestParameters, initOverrides) {
+        return _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling getMfaDeviceOptions.');
+            }
+            if (requestParameters.mfaDeviceId === null || requestParameters.mfaDeviceId === undefined) {
+                throw new runtime.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 runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    getMfaDeviceOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.getMfaDeviceOptionsRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Find the configuration for the enabled networks associated to an environment
      */
@@ -1082,6 +1367,41 @@ class SDKApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Get recovery codes
+     */
+    getRecoveryCodesRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.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 runtime.JSONApiResponse(response, (jsonValue) => MFAGetRecoveryCodesResponse.MFAGetRecoveryCodesResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get recovery codes
+     */
+    getRecoveryCodes(requestParameters, initOverrides) {
+        return _tslib.__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
@@ -1130,6 +1450,41 @@ class SDKApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Get the current user\'s MFA Devices
+     */
+    getUserMfaDevicesRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.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 runtime.JSONApiResponse(response, (jsonValue) => MFAListDevicesResponse.MFAListDevicesResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Get the current user\'s MFA Devices
+     */
+    getUserMfaDevices(requestParameters, initOverrides) {
+        return _tslib.__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
      */
@@ -1276,6 +1631,33 @@ class SDKApi extends runtime.BaseAPI {
             yield this.jwksOptionsRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Options call for this endpoint
+     */
+    listMfaDevicesOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.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 runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    listMfaDevicesOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.listMfaDevicesOptionsRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Update SDK settings for a specific environment
      */
@@ -2104,6 +2486,33 @@ class SDKApi extends runtime.BaseAPI {
             yield this.publishEventRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Options call for this endpoint
+     */
+    recoveryCodesOptionsRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.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 runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    recoveryCodesOptions(requestParameters, initOverrides) {
+        return _tslib.__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
      */
@@ -2166,6 +2575,108 @@ class SDKApi extends runtime.BaseAPI {
             yield this.refreshOptionsRaw(requestParameters, initOverrides);
         });
     }
+    /**
+     * Register a new TOTP MFA device and get Totp Secret
+     */
+    registerTotpMfaDeviceRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.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 runtime.JSONApiResponse(response, (jsonValue) => MFARegisterTotpDeviceGetResponse.MFARegisterTotpDeviceGetResponseFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Register a new TOTP MFA device and get Totp Secret
+     */
+    registerTotpMfaDevice(requestParameters, initOverrides) {
+        return _tslib.__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 _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.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 runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Options call for this endpoint
+     */
+    registerTotpMfaDeviceOptions(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.registerTotpMfaDeviceOptionsRaw(requestParameters, initOverrides);
+        });
+    }
+    /**
+     * Verify TOTP MFA device
+     */
+    registerTotpMfaDeviceVerifyRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling registerTotpMfaDeviceVerify.');
+            }
+            if (requestParameters.mFARegisterTotpDevicePostRequest === null || requestParameters.mFARegisterTotpDevicePostRequest === undefined) {
+                throw new runtime.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: MFARegisterTotpDevicePostRequest.MFARegisterTotpDevicePostRequestToJSON(requestParameters.mFARegisterTotpDevicePostRequest),
+            }, initOverrides);
+            return new runtime.JSONApiResponse(response, (jsonValue) => MFADevice.MFADeviceFromJSON(jsonValue));
+        });
+    }
+    /**
+     * Verify TOTP MFA device
+     */
+    registerTotpMfaDeviceVerify(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            const response = yield this.registerTotpMfaDeviceVerifyRaw(requestParameters, initOverrides);
+            return yield response.value();
+        });
+    }
     /**
      * Send new code for email verification
      */
@@ -2599,6 +3110,45 @@ class SDKApi extends runtime.BaseAPI {
             return yield response.value();
         });
     }
+    /**
+     * Update a device
+     */
+    updateUserMfaDeviceRaw(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            if (requestParameters.environmentId === null || requestParameters.environmentId === undefined) {
+                throw new runtime.RequiredError('environmentId', 'Required parameter requestParameters.environmentId was null or undefined when calling updateUserMfaDevice.');
+            }
+            if (requestParameters.mfaDeviceId === null || requestParameters.mfaDeviceId === undefined) {
+                throw new runtime.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: MFAUpdateDeviceRequest.MFAUpdateDeviceRequestToJSON(requestParameters.mFAUpdateDeviceRequest),
+            }, initOverrides);
+            return new runtime.VoidApiResponse(response);
+        });
+    }
+    /**
+     * Update a device
+     */
+    updateUserMfaDevice(requestParameters, initOverrides) {
+        return _tslib.__awaiter(this, void 0, void 0, function* () {
+            yield this.updateUserMfaDeviceRaw(requestParameters, initOverrides);
+        });
+    }
     /**
      * Options call for this endpoint
      */