@randock/nameshift-api-client 0.0.503 → 0.0.504

package/dist/apis/UsersApi.js

@@ -75,6 +75,177 @@ var UsersApi = /** @class */ (function (_super) {
     function UsersApi() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * Turn the authenticator app on with one of its codes
+     */
+    UsersApi.prototype.activateUserTotpRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['activateUserTotpInput'] == null) {
+                            throw new runtime.RequiredError('activateUserTotpInput', 'Required parameter "activateUserTotpInput" was null or undefined when calling activateUserTotp().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/totp/activate",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.ActivateUserTotpInputToJSON)(requestParameters['activateUserTotpInput']),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     * Turn the authenticator app on with one of its codes
+     */
+    UsersApi.prototype.activateUserTotp = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.activateUserTotpRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * The new app replaces the current one. The sign-in method and the recovery codes stay as they are.
+     * Move to the new authenticator app with one of its codes
+     */
+    UsersApi.prototype.activateUserTotpReplacementRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['activateUserTotpInput'] == null) {
+                            throw new runtime.RequiredError('activateUserTotpInput', 'Required parameter "activateUserTotpInput" was null or undefined when calling activateUserTotpReplacement().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/totp/replace/activate",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.ActivateUserTotpInputToJSON)(requestParameters['activateUserTotpInput']),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     * The new app replaces the current one. The sign-in method and the recovery codes stay as they are.
+     * Move to the new authenticator app with one of its codes
+     */
+    UsersApi.prototype.activateUserTotpReplacement = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.activateUserTotpReplacementRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Only to a method the factors set up allow (see allowedAuthenticationMethods). Needs the reauthentication token: a stronger method can also lock the user out of a sign-in they rely on.
+     * Change the method the user signs in with
+     */
+    UsersApi.prototype.changeUserAuthenticationMethodRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['xReauthenticationToken'] == null) {
+                            throw new runtime.RequiredError('xReauthenticationToken', 'Required parameter "xReauthenticationToken" was null or undefined when calling changeUserAuthenticationMethod().');
+                        }
+                        if (requestParameters['changeUserAuthenticationMethodInput'] == null) {
+                            throw new runtime.RequiredError('changeUserAuthenticationMethodInput', 'Required parameter "changeUserAuthenticationMethodInput" was null or undefined when calling changeUserAuthenticationMethod().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (requestParameters['xReauthenticationToken'] != null) {
+                            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/authentication-method",
+                            method: 'PATCH',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.ChangeUserAuthenticationMethodInputToJSON)(requestParameters['changeUserAuthenticationMethodInput']),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.UserSecurityDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Only to a method the factors set up allow (see allowedAuthenticationMethods). Needs the reauthentication token: a stronger method can also lock the user out of a sign-in they rely on.
+     * Change the method the user signs in with
+     */
+    UsersApi.prototype.changeUserAuthenticationMethod = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.changeUserAuthenticationMethodRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Changes the seller user email after validating the OTP sent to the new address.  **API key scope required:** `USER_EMAIL_WRITE`. Requests authenticated with a seller session do not need any scope.
      * Change user email with OTP
@@ -107,93 +278,951 @@ var UsersApi = /** @class */ (function (_super) {
                         if (tokenString) {
                             headerParameters["Authorization"] = "Bearer ".concat(tokenString);
                         }
-                        _c.label = 4;
-                    case 4: return [4 /*yield*/, this.request({
-                            path: "/private/users/email",
-                            method: 'PATCH',
+                        _c.label = 4;
+                    case 4: return [4 /*yield*/, this.request({
+                            path: "/private/users/email",
+                            method: 'PATCH',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.ChangeUserEmailWithOtpInputToJSON)(requestParameters['changeUserEmailWithOtpInput']),
+                        }, initOverrides)];
+                    case 5:
+                        response = _c.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     * Changes the seller user email after validating the OTP sent to the new address.  **API key scope required:** `USER_EMAIL_WRITE`. Requests authenticated with a seller session do not need any scope.
+     * Change user email with OTP
+     */
+    UsersApi.prototype.changeUserEmailWithOtp = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.changeUserEmailWithOtpRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Turning it off needs the reauthentication token.
+     * Turn the email confirmation of new locations on or off
+     */
+    UsersApi.prototype.changeUserLoginLocationVerificationRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['changeUserLoginLocationVerificationInput'] == null) {
+                            throw new runtime.RequiredError('changeUserLoginLocationVerificationInput', 'Required parameter "changeUserLoginLocationVerificationInput" was null or undefined when calling changeUserLoginLocationVerification().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (requestParameters['xReauthenticationToken'] != null) {
+                            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/login-location-verification",
+                            method: 'PATCH',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.ChangeUserLoginLocationVerificationInputToJSON)(requestParameters['changeUserLoginLocationVerificationInput']),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.UserSecurityDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Turning it off needs the reauthentication token.
+     * Turn the email confirmation of new locations on or off
+     */
+    UsersApi.prototype.changeUserLoginLocationVerification = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.changeUserLoginLocationVerificationRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Requires the current password.
+     * Change the password
+     */
+    UsersApi.prototype.changeUserPasswordRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['changeUserPasswordInput'] == null) {
+                            throw new runtime.RequiredError('changeUserPasswordInput', 'Required parameter "changeUserPasswordInput" was null or undefined when calling changeUserPassword().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/password",
+                            method: 'PATCH',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.ChangeUserPasswordInputToJSON)(requestParameters['changeUserPasswordInput']),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     * Requires the current password.
+     * Change the password
+     */
+    UsersApi.prototype.changeUserPassword = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.changeUserPasswordRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * The current codes stop working.
+     * Turn recovery codes off
+     */
+    UsersApi.prototype.disableUserRecoveryCodesRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['xReauthenticationToken'] == null) {
+                            throw new runtime.RequiredError('xReauthenticationToken', 'Required parameter "xReauthenticationToken" was null or undefined when calling disableUserRecoveryCodes().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (requestParameters['xReauthenticationToken'] != null) {
+                            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/recovery-codes",
+                            method: 'DELETE',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     * The current codes stop working.
+     * Turn recovery codes off
+     */
+    UsersApi.prototype.disableUserRecoveryCodes = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.disableUserRecoveryCodesRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Needs a code of the app being turned off. Wrong codes count towards locking the verification step.
+     * Turn the authenticator app off
+     */
+    UsersApi.prototype.disableUserTotpRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['totpCodeInput'] == null) {
+                            throw new runtime.RequiredError('totpCodeInput', 'Required parameter "totpCodeInput" was null or undefined when calling disableUserTotp().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/totp",
+                            method: 'DELETE',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.TotpCodeInputToJSON)(requestParameters['totpCodeInput']),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     * Needs a code of the app being turned off. Wrong codes count towards locking the verification step.
+     * Turn the authenticator app off
+     */
+    UsersApi.prototype.disableUserTotp = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.disableUserTotpRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Returns the codes, only this once. Needs an authenticator app or a passkey for them to stand in for.
+     * Turn recovery codes on
+     */
+    UsersApi.prototype.enableUserRecoveryCodesRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['xReauthenticationToken'] == null) {
+                            throw new runtime.RequiredError('xReauthenticationToken', 'Required parameter "xReauthenticationToken" was null or undefined when calling enableUserRecoveryCodes().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (requestParameters['xReauthenticationToken'] != null) {
+                            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/recovery-codes/enable",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.RecoveryCodesDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Returns the codes, only this once. Needs an authenticator app or a passkey for them to stand in for.
+     * Turn recovery codes on
+     */
+    UsersApi.prototype.enableUserRecoveryCodes = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.enableUserRecoveryCodesRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Start confirming it is you with a passkey
+     */
+    UsersApi.prototype.getReauthenticationPasskeyOptionsRaw = function (initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/reauthenticate/passkey/options",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.PasskeyOptionsDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Start confirming it is you with a passkey
+     */
+    UsersApi.prototype.getReauthenticationPasskeyOptions = function (initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getReauthenticationPasskeyOptionsRaw(initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Returns the notification preferences configured for the seller user.  **API key scope required:** `USERS_READ`. Requests authenticated with a seller session do not need any scope.
+     * Get user notification settings
+     */
+    UsersApi.prototype.getUserNotificationSettingsRaw = function (initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, _a, _b, token, tokenString, response;
+            return __generator(this, function (_c) {
+                switch (_c.label) {
+                    case 0:
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.apiKey)) return [3 /*break*/, 2];
+                        _a = headerParameters;
+                        _b = "apikey";
+                        return [4 /*yield*/, this.configuration.apiKey("apikey")];
+                    case 1:
+                        _a[_b] = _c.sent(); // api_key authentication
+                        _c.label = 2;
+                    case 2:
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 4];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 3:
+                        tokenString = _c.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _c.label = 4;
+                    case 4: return [4 /*yield*/, this.request({
+                            path: "/private/users/notification-settings",
+                            method: 'GET',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 5:
+                        response = _c.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.UserNotificationSettingsDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Returns the notification preferences configured for the seller user.  **API key scope required:** `USERS_READ`. Requests authenticated with a seller session do not need any scope.
+     * Get user notification settings
+     */
+    UsersApi.prototype.getUserNotificationSettings = function (initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getUserNotificationSettingsRaw(initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Needs the reauthentication token: a passkey signs in on its own.
+     * Start adding a passkey
+     */
+    UsersApi.prototype.getUserPasskeyRegistrationOptionsRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['xReauthenticationToken'] == null) {
+                            throw new runtime.RequiredError('xReauthenticationToken', 'Required parameter "xReauthenticationToken" was null or undefined when calling getUserPasskeyRegistrationOptions().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (requestParameters['xReauthenticationToken'] != null) {
+                            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/passkeys/options",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.PasskeyOptionsDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Needs the reauthentication token: a passkey signs in on its own.
+     * Start adding a passkey
+     */
+    UsersApi.prototype.getUserPasskeyRegistrationOptions = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getUserPasskeyRegistrationOptionsRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Only that passkey can answer.
+     * Start using a passkey to prove it, before removing it
+     */
+    UsersApi.prototype.getUserPasskeyVerificationOptionsRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['passkeyId'] == null) {
+                            throw new runtime.RequiredError('passkeyId', 'Required parameter "passkeyId" was null or undefined when calling getUserPasskeyVerificationOptions().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/passkeys/{passkeyId}/verification-options".replace("{".concat("passkeyId", "}"), encodeURIComponent(String(requestParameters['passkeyId']))),
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.PasskeyOptionsDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Only that passkey can answer.
+     * Start using a passkey to prove it, before removing it
+     */
+    UsersApi.prototype.getUserPasskeyVerificationOptions = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getUserPasskeyVerificationOptionsRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Get how the user signs in
+     */
+    UsersApi.prototype.getUserSecurityRaw = function (initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security",
+                            method: 'GET',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.UserSecurityDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Get how the user signs in
+     */
+    UsersApi.prototype.getUserSecurity = function (initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getUserSecurityRaw(initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Every step of every sign-in, successful or not, newest first by default.
+     * List the sign-ins of the user
+     */
+    UsersApi.prototype.listUserLoginAttemptsRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        queryParameters = {};
+                        if (requestParameters['filter'] != null) {
+                            queryParameters['filter'] = requestParameters['filter'];
+                        }
+                        if (requestParameters['page'] != null) {
+                            queryParameters['page'] = requestParameters['page'];
+                        }
+                        if (requestParameters['limit'] != null) {
+                            queryParameters['limit'] = requestParameters['limit'];
+                        }
+                        if (requestParameters['sortBy'] != null) {
+                            queryParameters['sortBy'] = requestParameters['sortBy'];
+                        }
+                        if (requestParameters['filterResult'] != null) {
+                            queryParameters['filter[result]'] = requestParameters['filterResult'];
+                        }
+                        if (requestParameters['filterMethod'] != null) {
+                            queryParameters['filter[method]'] = requestParameters['filterMethod'];
+                        }
+                        headerParameters = {};
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/login-attempts",
+                            method: 'GET',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.ListUserLoginAttempts200ResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Every step of every sign-in, successful or not, newest first by default.
+     * List the sign-ins of the user
+     */
+    UsersApi.prototype.listUserLoginAttempts = function () {
+        return __awaiter(this, arguments, void 0, function (requestParameters, initOverrides) {
+            var response;
+            if (requestParameters === void 0) { requestParameters = {}; }
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.listUserLoginAttemptsRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * For the next ten minutes, sensitive changes accept the returned token.
+     * Confirm it is you with a passkey
+     */
+    UsersApi.prototype.reauthenticateWithPasskeyRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['reauthenticateWithPasskeyInput'] == null) {
+                            throw new runtime.RequiredError('reauthenticateWithPasskeyInput', 'Required parameter "reauthenticateWithPasskeyInput" was null or undefined when calling reauthenticateWithPasskey().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/reauthenticate/passkey",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.ReauthenticateWithPasskeyInputToJSON)(requestParameters['reauthenticateWithPasskeyInput']),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.ReauthenticationDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * For the next ten minutes, sensitive changes accept the returned token.
+     * Confirm it is you with a passkey
+     */
+    UsersApi.prototype.reauthenticateWithPasskey = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.reauthenticateWithPasskeyRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * For the next ten minutes, sensitive changes accept the returned token.
+     * Confirm it is you with your password
+     */
+    UsersApi.prototype.reauthenticateWithPasswordRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['currentPasswordInput'] == null) {
+                            throw new runtime.RequiredError('currentPasswordInput', 'Required parameter "currentPasswordInput" was null or undefined when calling reauthenticateWithPassword().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/reauthenticate/password",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.CurrentPasswordInputToJSON)(requestParameters['currentPasswordInput']),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.ReauthenticationDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * For the next ten minutes, sensitive changes accept the returned token.
+     * Confirm it is you with your password
+     */
+    UsersApi.prototype.reauthenticateWithPassword = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.reauthenticateWithPasswordRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * For the next ten minutes, sensitive changes accept the returned token. Wrong codes count towards locking the verification step.
+     * Confirm it is you with the code from your authenticator app
+     */
+    UsersApi.prototype.reauthenticateWithTotpRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['activateUserTotpInput'] == null) {
+                            throw new runtime.RequiredError('activateUserTotpInput', 'Required parameter "activateUserTotpInput" was null or undefined when calling reauthenticateWithTotp().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/reauthenticate/totp",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.ActivateUserTotpInputToJSON)(requestParameters['activateUserTotpInput']),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.ReauthenticationDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * For the next ten minutes, sensitive changes accept the returned token. Wrong codes count towards locking the verification step.
+     * Confirm it is you with the code from your authenticator app
+     */
+    UsersApi.prototype.reauthenticateWithTotp = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.reauthenticateWithTotpRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * The previous codes stop working. Only while recovery codes are on.
+     * Replace the recovery codes
+     */
+    UsersApi.prototype.regenerateUserRecoveryCodesRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['xReauthenticationToken'] == null) {
+                            throw new runtime.RequiredError('xReauthenticationToken', 'Required parameter "xReauthenticationToken" was null or undefined when calling regenerateUserRecoveryCodes().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (requestParameters['xReauthenticationToken'] != null) {
+                            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/recovery-codes",
+                            method: 'POST',
                             headers: headerParameters,
                             query: queryParameters,
-                            body: (0, index_1.ChangeUserEmailWithOtpInputToJSON)(requestParameters['changeUserEmailWithOtpInput']),
                         }, initOverrides)];
-                    case 5:
-                        response = _c.sent();
-                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.RecoveryCodesDtoFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
-     * Changes the seller user email after validating the OTP sent to the new address.  **API key scope required:** `USER_EMAIL_WRITE`. Requests authenticated with a seller session do not need any scope.
-     * Change user email with OTP
+     * The previous codes stop working. Only while recovery codes are on.
+     * Replace the recovery codes
      */
-    UsersApi.prototype.changeUserEmailWithOtp = function (requestParameters, initOverrides) {
+    UsersApi.prototype.regenerateUserRecoveryCodes = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
+            var response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.changeUserEmailWithOtpRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.regenerateUserRecoveryCodesRaw(requestParameters, initOverrides)];
                     case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
     /**
-     * Returns the notification preferences configured for the seller user.  **API key scope required:** `USERS_READ`. Requests authenticated with a seller session do not need any scope.
-     * Get user notification settings
+     * Needs the reauthentication token: a passkey signs in on its own.
+     * Add a passkey
      */
-    UsersApi.prototype.getUserNotificationSettingsRaw = function (initOverrides) {
+    UsersApi.prototype.registerUserPasskeyRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, _a, _b, token, tokenString, response;
-            return __generator(this, function (_c) {
-                switch (_c.label) {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
                     case 0:
+                        if (requestParameters['xReauthenticationToken'] == null) {
+                            throw new runtime.RequiredError('xReauthenticationToken', 'Required parameter "xReauthenticationToken" was null or undefined when calling registerUserPasskey().');
+                        }
+                        if (requestParameters['registerUserPasskeyInput'] == null) {
+                            throw new runtime.RequiredError('registerUserPasskeyInput', 'Required parameter "registerUserPasskeyInput" was null or undefined when calling registerUserPasskey().');
+                        }
                         queryParameters = {};
                         headerParameters = {};
-                        if (!(this.configuration && this.configuration.apiKey)) return [3 /*break*/, 2];
-                        _a = headerParameters;
-                        _b = "apikey";
-                        return [4 /*yield*/, this.configuration.apiKey("apikey")];
-                    case 1:
-                        _a[_b] = _c.sent(); // api_key authentication
-                        _c.label = 2;
-                    case 2:
-                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 4];
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (requestParameters['xReauthenticationToken'] != null) {
+                            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
                         token = this.configuration.accessToken;
                         return [4 /*yield*/, token("bearer", [])];
-                    case 3:
-                        tokenString = _c.sent();
+                    case 1:
+                        tokenString = _a.sent();
                         if (tokenString) {
                             headerParameters["Authorization"] = "Bearer ".concat(tokenString);
                         }
-                        _c.label = 4;
-                    case 4: return [4 /*yield*/, this.request({
-                            path: "/private/users/notification-settings",
-                            method: 'GET',
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/passkeys",
+                            method: 'POST',
                             headers: headerParameters,
                             query: queryParameters,
+                            body: (0, index_1.RegisterUserPasskeyInputToJSON)(requestParameters['registerUserPasskeyInput']),
                         }, initOverrides)];
-                    case 5:
-                        response = _c.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.UserNotificationSettingsDtoFromJSON)(jsonValue); })];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
                 }
             });
         });
     };
     /**
-     * Returns the notification preferences configured for the seller user.  **API key scope required:** `USERS_READ`. Requests authenticated with a seller session do not need any scope.
-     * Get user notification settings
+     * Needs the reauthentication token: a passkey signs in on its own.
+     * Add a passkey
      */
-    UsersApi.prototype.getUserNotificationSettings = function (initOverrides) {
+    UsersApi.prototype.registerUserPasskey = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
-            var response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getUserNotificationSettingsRaw(initOverrides)];
+                    case 0: return [4 /*yield*/, this.registerUserPasskeyRaw(requestParameters, initOverrides)];
                     case 1:
-                        response = _a.sent();
-                        return [4 /*yield*/, response.value()];
-                    case 2: return [2 /*return*/, _a.sent()];
+                        _a.sent();
+                        return [2 /*return*/];
                 }
             });
         });
@@ -253,6 +1282,64 @@ var UsersApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Needs that very passkey, used one last time (see the verification options).
+     * Remove a passkey
+     */
+    UsersApi.prototype.removeUserPasskeyRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['passkeyId'] == null) {
+                            throw new runtime.RequiredError('passkeyId', 'Required parameter "passkeyId" was null or undefined when calling removeUserPasskey().');
+                        }
+                        if (requestParameters['removeUserPasskeyInput'] == null) {
+                            throw new runtime.RequiredError('removeUserPasskeyInput', 'Required parameter "removeUserPasskeyInput" was null or undefined when calling removeUserPasskey().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/passkeys/{passkeyId}".replace("{".concat("passkeyId", "}"), encodeURIComponent(String(requestParameters['passkeyId']))),
+                            method: 'DELETE',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.RemoveUserPasskeyInputToJSON)(requestParameters['removeUserPasskeyInput']),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     * Needs that very passkey, used one last time (see the verification options).
+     * Remove a passkey
+     */
+    UsersApi.prototype.removeUserPasskey = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.removeUserPasskeyRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Unregisters an Expo push token for the current user, e.g. on logout. Seller session only.
      * Remove a push token
@@ -306,6 +1393,62 @@ var UsersApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Rename a passkey
+     */
+    UsersApi.prototype.renameUserPasskeyRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['passkeyId'] == null) {
+                            throw new runtime.RequiredError('passkeyId', 'Required parameter "passkeyId" was null or undefined when calling renameUserPasskey().');
+                        }
+                        if (requestParameters['renameUserPasskeyInput'] == null) {
+                            throw new runtime.RequiredError('renameUserPasskeyInput', 'Required parameter "renameUserPasskeyInput" was null or undefined when calling renameUserPasskey().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/passkeys/{passkeyId}".replace("{".concat("passkeyId", "}"), encodeURIComponent(String(requestParameters['passkeyId']))),
+                            method: 'PATCH',
+                            headers: headerParameters,
+                            query: queryParameters,
+                            body: (0, index_1.RenameUserPasskeyInputToJSON)(requestParameters['renameUserPasskeyInput']),
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     * Rename a passkey
+     */
+    UsersApi.prototype.renameUserPasskey = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.renameUserPasskeyRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Sends a one-time password to the new email address to verify ownership before changing the account email.  **API key scope required:** `USER_EMAIL_WRITE`. Requests authenticated with a seller session do not need any scope.
      * Request email change OTP
@@ -432,6 +1575,122 @@ var UsersApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Returns the QR code URI and the secret to type by hand. The app is only turned on once a code of it is checked; a new call replaces the secret. Needs the reauthentication token: whoever sets up the app holds the verification step.
+     * Start setting up an authenticator app
+     */
+    UsersApi.prototype.startUserTotpEnrolmentRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['xReauthenticationToken'] == null) {
+                            throw new runtime.RequiredError('xReauthenticationToken', 'Required parameter "xReauthenticationToken" was null or undefined when calling startUserTotpEnrolment().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (requestParameters['xReauthenticationToken'] != null) {
+                            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/totp",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.TotpEnrolmentDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Returns the QR code URI and the secret to type by hand. The app is only turned on once a code of it is checked; a new call replaces the secret. Needs the reauthentication token: whoever sets up the app holds the verification step.
+     * Start setting up an authenticator app
+     */
+    UsersApi.prototype.startUserTotpEnrolment = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.startUserTotpEnrolmentRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Returns the QR code URI and the secret of the new app. The current app keeps working until a code of the new one is checked.
+     * Start moving to another authenticator app
+     */
+    UsersApi.prototype.startUserTotpReplacementRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, token, tokenString, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['xReauthenticationToken'] == null) {
+                            throw new runtime.RequiredError('xReauthenticationToken', 'Required parameter "xReauthenticationToken" was null or undefined when calling startUserTotpReplacement().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        if (requestParameters['xReauthenticationToken'] != null) {
+                            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+                        }
+                        if (!(this.configuration && this.configuration.accessToken)) return [3 /*break*/, 2];
+                        token = this.configuration.accessToken;
+                        return [4 /*yield*/, token("bearer", [])];
+                    case 1:
+                        tokenString = _a.sent();
+                        if (tokenString) {
+                            headerParameters["Authorization"] = "Bearer ".concat(tokenString);
+                        }
+                        _a.label = 2;
+                    case 2: return [4 /*yield*/, this.request({
+                            path: "/private/users/security/totp/replace",
+                            method: 'POST',
+                            headers: headerParameters,
+                            query: queryParameters,
+                        }, initOverrides)];
+                    case 3:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.TotpEnrolmentDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Returns the QR code URI and the secret of the new app. The current app keeps working until a code of the new one is checked.
+     * Start moving to another authenticator app
+     */
+    UsersApi.prototype.startUserTotpReplacement = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.startUserTotpReplacementRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Updates one or more notification preferences for the seller user.  **API key scope required:** `USERS_WRITE`. Requests authenticated with a seller session do not need any scope.
      * Update user notification settings