@randock/nameshift-api-client 0.0.503 → 0.0.504

package/src/apis/UsersApi.ts

@@ -15,69 +15,984 @@
 
 import * as runtime from '../runtime';
 import type {
+  ActivateUserTotpInput,
+  ChangeUserAuthenticationMethodInput,
   ChangeUserEmailWithOtpInput,
+  ChangeUserLoginLocationVerificationInput,
+  ChangeUserPasswordInput,
+  CurrentPasswordInput,
+  ListUserLoginAttempts200Response,
+  PasskeyOptionsDto,
+  ReauthenticateWithPasskeyInput,
+  ReauthenticationDto,
+  RecoveryCodesDto,
+  RegisterUserPasskeyInput,
   RegisterUserPushTokenInput,
+  RemoveUserPasskeyInput,
+  RenameUserPasskeyInput,
   RequestUserEmailChangeOtpInput,
   StoreUserLocaleInput,
+  TotpCodeInput,
+  TotpEnrolmentDto,
   UpdateUserNotificationSettingsInput,
   UserNotificationSettingsDto,
+  UserSecurityDto,
   ValidationException,
 } from '../models/index';
 import {
+    ActivateUserTotpInputFromJSON,
+    ActivateUserTotpInputToJSON,
+    ChangeUserAuthenticationMethodInputFromJSON,
+    ChangeUserAuthenticationMethodInputToJSON,
     ChangeUserEmailWithOtpInputFromJSON,
     ChangeUserEmailWithOtpInputToJSON,
+    ChangeUserLoginLocationVerificationInputFromJSON,
+    ChangeUserLoginLocationVerificationInputToJSON,
+    ChangeUserPasswordInputFromJSON,
+    ChangeUserPasswordInputToJSON,
+    CurrentPasswordInputFromJSON,
+    CurrentPasswordInputToJSON,
+    ListUserLoginAttempts200ResponseFromJSON,
+    ListUserLoginAttempts200ResponseToJSON,
+    PasskeyOptionsDtoFromJSON,
+    PasskeyOptionsDtoToJSON,
+    ReauthenticateWithPasskeyInputFromJSON,
+    ReauthenticateWithPasskeyInputToJSON,
+    ReauthenticationDtoFromJSON,
+    ReauthenticationDtoToJSON,
+    RecoveryCodesDtoFromJSON,
+    RecoveryCodesDtoToJSON,
+    RegisterUserPasskeyInputFromJSON,
+    RegisterUserPasskeyInputToJSON,
     RegisterUserPushTokenInputFromJSON,
     RegisterUserPushTokenInputToJSON,
+    RemoveUserPasskeyInputFromJSON,
+    RemoveUserPasskeyInputToJSON,
+    RenameUserPasskeyInputFromJSON,
+    RenameUserPasskeyInputToJSON,
     RequestUserEmailChangeOtpInputFromJSON,
     RequestUserEmailChangeOtpInputToJSON,
     StoreUserLocaleInputFromJSON,
     StoreUserLocaleInputToJSON,
+    TotpCodeInputFromJSON,
+    TotpCodeInputToJSON,
+    TotpEnrolmentDtoFromJSON,
+    TotpEnrolmentDtoToJSON,
     UpdateUserNotificationSettingsInputFromJSON,
     UpdateUserNotificationSettingsInputToJSON,
     UserNotificationSettingsDtoFromJSON,
     UserNotificationSettingsDtoToJSON,
+    UserSecurityDtoFromJSON,
+    UserSecurityDtoToJSON,
     ValidationExceptionFromJSON,
     ValidationExceptionToJSON,
 } from '../models/index';
 
+export interface UsersApiActivateUserTotpRequest {
+    activateUserTotpInput: ActivateUserTotpInput;
+}
+
+export interface UsersApiActivateUserTotpReplacementRequest {
+    activateUserTotpInput: ActivateUserTotpInput;
+}
+
+export interface UsersApiChangeUserAuthenticationMethodRequest {
+    xReauthenticationToken: string;
+    changeUserAuthenticationMethodInput: ChangeUserAuthenticationMethodInput;
+}
+
 export interface UsersApiChangeUserEmailWithOtpRequest {
     changeUserEmailWithOtpInput: ChangeUserEmailWithOtpInput;
 }
 
-export interface UsersApiRegisterUserPushTokenRequest {
-    registerUserPushTokenInput: RegisterUserPushTokenInput;
-}
+export interface UsersApiChangeUserLoginLocationVerificationRequest {
+    changeUserLoginLocationVerificationInput: ChangeUserLoginLocationVerificationInput;
+    xReauthenticationToken?: string;
+}
+
+export interface UsersApiChangeUserPasswordRequest {
+    changeUserPasswordInput: ChangeUserPasswordInput;
+}
+
+export interface UsersApiDisableUserRecoveryCodesRequest {
+    xReauthenticationToken: string;
+}
+
+export interface UsersApiDisableUserTotpRequest {
+    totpCodeInput: TotpCodeInput;
+}
+
+export interface UsersApiEnableUserRecoveryCodesRequest {
+    xReauthenticationToken: string;
+}
+
+export interface UsersApiGetUserPasskeyRegistrationOptionsRequest {
+    xReauthenticationToken: string;
+}
+
+export interface UsersApiGetUserPasskeyVerificationOptionsRequest {
+    passkeyId: string;
+}
+
+export interface UsersApiListUserLoginAttemptsRequest {
+    filter?: { [key: string]: string; };
+    page?: number;
+    limit?: number;
+    sortBy?: Array<string>;
+    filterResult?: string;
+    filterMethod?: string;
+}
+
+export interface UsersApiReauthenticateWithPasskeyRequest {
+    reauthenticateWithPasskeyInput: ReauthenticateWithPasskeyInput;
+}
+
+export interface UsersApiReauthenticateWithPasswordRequest {
+    currentPasswordInput: CurrentPasswordInput;
+}
+
+export interface UsersApiReauthenticateWithTotpRequest {
+    activateUserTotpInput: ActivateUserTotpInput;
+}
+
+export interface UsersApiRegenerateUserRecoveryCodesRequest {
+    xReauthenticationToken: string;
+}
+
+export interface UsersApiRegisterUserPasskeyRequest {
+    xReauthenticationToken: string;
+    registerUserPasskeyInput: RegisterUserPasskeyInput;
+}
+
+export interface UsersApiRegisterUserPushTokenRequest {
+    registerUserPushTokenInput: RegisterUserPushTokenInput;
+}
+
+export interface UsersApiRemoveUserPasskeyRequest {
+    passkeyId: string;
+    removeUserPasskeyInput: RemoveUserPasskeyInput;
+}
+
+export interface UsersApiRemoveUserPushTokenRequest {
+    token: string;
+}
+
+export interface UsersApiRenameUserPasskeyRequest {
+    passkeyId: string;
+    renameUserPasskeyInput: RenameUserPasskeyInput;
+}
+
+export interface UsersApiRequestUserEmailChangeOtpRequest {
+    requestUserEmailChangeOtpInput: RequestUserEmailChangeOtpInput;
+}
+
+export interface UsersApiSetLocaleRequest {
+    storeUserLocaleInput: StoreUserLocaleInput;
+}
+
+export interface UsersApiStartUserTotpEnrolmentRequest {
+    xReauthenticationToken: string;
+}
+
+export interface UsersApiStartUserTotpReplacementRequest {
+    xReauthenticationToken: string;
+}
+
+export interface UsersApiUpdateUserNotificationSettingsRequest {
+    updateUserNotificationSettingsInput: UpdateUserNotificationSettingsInput;
+}
+
+/**
+ * 
+ */
+export class UsersApi extends runtime.BaseAPI {
+
+    /**
+     * Turn the authenticator app on with one of its codes
+     */
+    async activateUserTotpRaw(requestParameters: UsersApiActivateUserTotpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['activateUserTotpInput'] == null) {
+            throw new runtime.RequiredError(
+                'activateUserTotpInput',
+                'Required parameter "activateUserTotpInput" was null or undefined when calling activateUserTotp().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/totp/activate`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ActivateUserTotpInputToJSON(requestParameters['activateUserTotpInput']),
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Turn the authenticator app on with one of its codes
+     */
+    async activateUserTotp(requestParameters: UsersApiActivateUserTotpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.activateUserTotpRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * 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
+     */
+    async activateUserTotpReplacementRaw(requestParameters: UsersApiActivateUserTotpReplacementRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['activateUserTotpInput'] == null) {
+            throw new runtime.RequiredError(
+                'activateUserTotpInput',
+                'Required parameter "activateUserTotpInput" was null or undefined when calling activateUserTotpReplacement().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/totp/replace/activate`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ActivateUserTotpInputToJSON(requestParameters['activateUserTotpInput']),
+        }, initOverrides);
+
+        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
+     */
+    async activateUserTotpReplacement(requestParameters: UsersApiActivateUserTotpReplacementRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.activateUserTotpReplacementRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * 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
+     */
+    async changeUserAuthenticationMethodRaw(requestParameters: UsersApiChangeUserAuthenticationMethodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSecurityDto>> {
+        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().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (requestParameters['xReauthenticationToken'] != null) {
+            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/authentication-method`,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ChangeUserAuthenticationMethodInputToJSON(requestParameters['changeUserAuthenticationMethodInput']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => 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
+     */
+    async changeUserAuthenticationMethod(requestParameters: UsersApiChangeUserAuthenticationMethodRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSecurityDto> {
+        const response = await this.changeUserAuthenticationMethodRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * 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
+     */
+    async changeUserEmailWithOtpRaw(requestParameters: UsersApiChangeUserEmailWithOtpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['changeUserEmailWithOtpInput'] == null) {
+            throw new runtime.RequiredError(
+                'changeUserEmailWithOtpInput',
+                'Required parameter "changeUserEmailWithOtpInput" was null or undefined when calling changeUserEmailWithOtp().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["apikey"] = await this.configuration.apiKey("apikey"); // api_key authentication
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/email`,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ChangeUserEmailWithOtpInputToJSON(requestParameters['changeUserEmailWithOtpInput']),
+        }, initOverrides);
+
+        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
+     */
+    async changeUserEmailWithOtp(requestParameters: UsersApiChangeUserEmailWithOtpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.changeUserEmailWithOtpRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Turning it off needs the reauthentication token.
+     * Turn the email confirmation of new locations on or off
+     */
+    async changeUserLoginLocationVerificationRaw(requestParameters: UsersApiChangeUserLoginLocationVerificationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSecurityDto>> {
+        if (requestParameters['changeUserLoginLocationVerificationInput'] == null) {
+            throw new runtime.RequiredError(
+                'changeUserLoginLocationVerificationInput',
+                'Required parameter "changeUserLoginLocationVerificationInput" was null or undefined when calling changeUserLoginLocationVerification().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (requestParameters['xReauthenticationToken'] != null) {
+            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/login-location-verification`,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ChangeUserLoginLocationVerificationInputToJSON(requestParameters['changeUserLoginLocationVerificationInput']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => UserSecurityDtoFromJSON(jsonValue));
+    }
+
+    /**
+     * Turning it off needs the reauthentication token.
+     * Turn the email confirmation of new locations on or off
+     */
+    async changeUserLoginLocationVerification(requestParameters: UsersApiChangeUserLoginLocationVerificationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSecurityDto> {
+        const response = await this.changeUserLoginLocationVerificationRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Requires the current password.
+     * Change the password
+     */
+    async changeUserPasswordRaw(requestParameters: UsersApiChangeUserPasswordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['changeUserPasswordInput'] == null) {
+            throw new runtime.RequiredError(
+                'changeUserPasswordInput',
+                'Required parameter "changeUserPasswordInput" was null or undefined when calling changeUserPassword().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/password`,
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ChangeUserPasswordInputToJSON(requestParameters['changeUserPasswordInput']),
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Requires the current password.
+     * Change the password
+     */
+    async changeUserPassword(requestParameters: UsersApiChangeUserPasswordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.changeUserPasswordRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * The current codes stop working.
+     * Turn recovery codes off
+     */
+    async disableUserRecoveryCodesRaw(requestParameters: UsersApiDisableUserRecoveryCodesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['xReauthenticationToken'] == null) {
+            throw new runtime.RequiredError(
+                'xReauthenticationToken',
+                'Required parameter "xReauthenticationToken" was null or undefined when calling disableUserRecoveryCodes().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xReauthenticationToken'] != null) {
+            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/recovery-codes`,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * The current codes stop working.
+     * Turn recovery codes off
+     */
+    async disableUserRecoveryCodes(requestParameters: UsersApiDisableUserRecoveryCodesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.disableUserRecoveryCodesRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Needs a code of the app being turned off. Wrong codes count towards locking the verification step.
+     * Turn the authenticator app off
+     */
+    async disableUserTotpRaw(requestParameters: UsersApiDisableUserTotpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        if (requestParameters['totpCodeInput'] == null) {
+            throw new runtime.RequiredError(
+                'totpCodeInput',
+                'Required parameter "totpCodeInput" was null or undefined when calling disableUserTotp().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/totp`,
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+            body: TotpCodeInputToJSON(requestParameters['totpCodeInput']),
+        }, initOverrides);
+
+        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
+     */
+    async disableUserTotp(requestParameters: UsersApiDisableUserTotpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.disableUserTotpRaw(requestParameters, initOverrides);
+    }
+
+    /**
+     * Returns the codes, only this once. Needs an authenticator app or a passkey for them to stand in for.
+     * Turn recovery codes on
+     */
+    async enableUserRecoveryCodesRaw(requestParameters: UsersApiEnableUserRecoveryCodesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecoveryCodesDto>> {
+        if (requestParameters['xReauthenticationToken'] == null) {
+            throw new runtime.RequiredError(
+                'xReauthenticationToken',
+                'Required parameter "xReauthenticationToken" was null or undefined when calling enableUserRecoveryCodes().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xReauthenticationToken'] != null) {
+            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/recovery-codes/enable`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => 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
+     */
+    async enableUserRecoveryCodes(requestParameters: UsersApiEnableUserRecoveryCodesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecoveryCodesDto> {
+        const response = await this.enableUserRecoveryCodesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Start confirming it is you with a passkey
+     */
+    async getReauthenticationPasskeyOptionsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PasskeyOptionsDto>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/reauthenticate/passkey/options`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PasskeyOptionsDtoFromJSON(jsonValue));
+    }
+
+    /**
+     * Start confirming it is you with a passkey
+     */
+    async getReauthenticationPasskeyOptions(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PasskeyOptionsDto> {
+        const response = await this.getReauthenticationPasskeyOptionsRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * 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
+     */
+    async getUserNotificationSettingsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserNotificationSettingsDto>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["apikey"] = await this.configuration.apiKey("apikey"); // api_key authentication
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/notification-settings`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => 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
+     */
+    async getUserNotificationSettings(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserNotificationSettingsDto> {
+        const response = await this.getUserNotificationSettingsRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Needs the reauthentication token: a passkey signs in on its own.
+     * Start adding a passkey
+     */
+    async getUserPasskeyRegistrationOptionsRaw(requestParameters: UsersApiGetUserPasskeyRegistrationOptionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PasskeyOptionsDto>> {
+        if (requestParameters['xReauthenticationToken'] == null) {
+            throw new runtime.RequiredError(
+                'xReauthenticationToken',
+                'Required parameter "xReauthenticationToken" was null or undefined when calling getUserPasskeyRegistrationOptions().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xReauthenticationToken'] != null) {
+            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/passkeys/options`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PasskeyOptionsDtoFromJSON(jsonValue));
+    }
+
+    /**
+     * Needs the reauthentication token: a passkey signs in on its own.
+     * Start adding a passkey
+     */
+    async getUserPasskeyRegistrationOptions(requestParameters: UsersApiGetUserPasskeyRegistrationOptionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PasskeyOptionsDto> {
+        const response = await this.getUserPasskeyRegistrationOptionsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Only that passkey can answer.
+     * Start using a passkey to prove it, before removing it
+     */
+    async getUserPasskeyVerificationOptionsRaw(requestParameters: UsersApiGetUserPasskeyVerificationOptionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PasskeyOptionsDto>> {
+        if (requestParameters['passkeyId'] == null) {
+            throw new runtime.RequiredError(
+                'passkeyId',
+                'Required parameter "passkeyId" was null or undefined when calling getUserPasskeyVerificationOptions().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/passkeys/{passkeyId}/verification-options`.replace(`{${"passkeyId"}}`, encodeURIComponent(String(requestParameters['passkeyId']))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => PasskeyOptionsDtoFromJSON(jsonValue));
+    }
+
+    /**
+     * Only that passkey can answer.
+     * Start using a passkey to prove it, before removing it
+     */
+    async getUserPasskeyVerificationOptions(requestParameters: UsersApiGetUserPasskeyVerificationOptionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PasskeyOptionsDto> {
+        const response = await this.getUserPasskeyVerificationOptionsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Get how the user signs in
+     */
+    async getUserSecurityRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserSecurityDto>> {
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => UserSecurityDtoFromJSON(jsonValue));
+    }
+
+    /**
+     * Get how the user signs in
+     */
+    async getUserSecurity(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserSecurityDto> {
+        const response = await this.getUserSecurityRaw(initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * Every step of every sign-in, successful or not, newest first by default.
+     * List the sign-ins of the user
+     */
+    async listUserLoginAttemptsRaw(requestParameters: UsersApiListUserLoginAttemptsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ListUserLoginAttempts200Response>> {
+        const queryParameters: any = {};
+
+        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'];
+        }
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/login-attempts`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ListUserLoginAttempts200ResponseFromJSON(jsonValue));
+    }
+
+    /**
+     * Every step of every sign-in, successful or not, newest first by default.
+     * List the sign-ins of the user
+     */
+    async listUserLoginAttempts(requestParameters: UsersApiListUserLoginAttemptsRequest = {}, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ListUserLoginAttempts200Response> {
+        const response = await this.listUserLoginAttemptsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * For the next ten minutes, sensitive changes accept the returned token.
+     * Confirm it is you with a passkey
+     */
+    async reauthenticateWithPasskeyRaw(requestParameters: UsersApiReauthenticateWithPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ReauthenticationDto>> {
+        if (requestParameters['reauthenticateWithPasskeyInput'] == null) {
+            throw new runtime.RequiredError(
+                'reauthenticateWithPasskeyInput',
+                'Required parameter "reauthenticateWithPasskeyInput" was null or undefined when calling reauthenticateWithPasskey().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/reauthenticate/passkey`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ReauthenticateWithPasskeyInputToJSON(requestParameters['reauthenticateWithPasskeyInput']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => ReauthenticationDtoFromJSON(jsonValue));
+    }
+
+    /**
+     * For the next ten minutes, sensitive changes accept the returned token.
+     * Confirm it is you with a passkey
+     */
+    async reauthenticateWithPasskey(requestParameters: UsersApiReauthenticateWithPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ReauthenticationDto> {
+        const response = await this.reauthenticateWithPasskeyRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * For the next ten minutes, sensitive changes accept the returned token.
+     * Confirm it is you with your password
+     */
+    async reauthenticateWithPasswordRaw(requestParameters: UsersApiReauthenticateWithPasswordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ReauthenticationDto>> {
+        if (requestParameters['currentPasswordInput'] == null) {
+            throw new runtime.RequiredError(
+                'currentPasswordInput',
+                'Required parameter "currentPasswordInput" was null or undefined when calling reauthenticateWithPassword().'
+            );
+        }
+
+        const queryParameters: any = {};
 
-export interface UsersApiRemoveUserPushTokenRequest {
-    token: string;
-}
+        const headerParameters: runtime.HTTPHeaders = {};
 
-export interface UsersApiRequestUserEmailChangeOtpRequest {
-    requestUserEmailChangeOtpInput: RequestUserEmailChangeOtpInput;
-}
+        headerParameters['Content-Type'] = 'application/json';
 
-export interface UsersApiSetLocaleRequest {
-    storeUserLocaleInput: StoreUserLocaleInput;
-}
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
 
-export interface UsersApiUpdateUserNotificationSettingsRequest {
-    updateUserNotificationSettingsInput: UpdateUserNotificationSettingsInput;
-}
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/reauthenticate/password`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: CurrentPasswordInputToJSON(requestParameters['currentPasswordInput']),
+        }, initOverrides);
 
-/**
- * 
- */
-export class UsersApi extends runtime.BaseAPI {
+        return new runtime.JSONApiResponse(response, (jsonValue) => ReauthenticationDtoFromJSON(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
+     * For the next ten minutes, sensitive changes accept the returned token.
+     * Confirm it is you with your password
      */
-    async changeUserEmailWithOtpRaw(requestParameters: UsersApiChangeUserEmailWithOtpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
-        if (requestParameters['changeUserEmailWithOtpInput'] == null) {
+    async reauthenticateWithPassword(requestParameters: UsersApiReauthenticateWithPasswordRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ReauthenticationDto> {
+        const response = await this.reauthenticateWithPasswordRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * 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
+     */
+    async reauthenticateWithTotpRaw(requestParameters: UsersApiReauthenticateWithTotpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<ReauthenticationDto>> {
+        if (requestParameters['activateUserTotpInput'] == null) {
             throw new runtime.RequiredError(
-                'changeUserEmailWithOtpInput',
-                'Required parameter "changeUserEmailWithOtpInput" was null or undefined when calling changeUserEmailWithOtp().'
+                'activateUserTotpInput',
+                'Required parameter "activateUserTotpInput" was null or undefined when calling reauthenticateWithTotp().'
             );
         }
 
@@ -87,8 +1002,52 @@ export class UsersApi extends runtime.BaseAPI {
 
         headerParameters['Content-Type'] = 'application/json';
 
-        if (this.configuration && this.configuration.apiKey) {
-            headerParameters["apikey"] = await this.configuration.apiKey("apikey"); // api_key authentication
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/reauthenticate/totp`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: ActivateUserTotpInputToJSON(requestParameters['activateUserTotpInput']),
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => 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
+     */
+    async reauthenticateWithTotp(requestParameters: UsersApiReauthenticateWithTotpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<ReauthenticationDto> {
+        const response = await this.reauthenticateWithTotpRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * The previous codes stop working. Only while recovery codes are on.
+     * Replace the recovery codes
+     */
+    async regenerateUserRecoveryCodesRaw(requestParameters: UsersApiRegenerateUserRecoveryCodesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<RecoveryCodesDto>> {
+        if (requestParameters['xReauthenticationToken'] == null) {
+            throw new runtime.RequiredError(
+                'xReauthenticationToken',
+                'Required parameter "xReauthenticationToken" was null or undefined when calling regenerateUserRecoveryCodes().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xReauthenticationToken'] != null) {
+            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
         }
 
         if (this.configuration && this.configuration.accessToken) {
@@ -100,35 +1059,51 @@ export class UsersApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/private/users/email`,
-            method: 'PATCH',
+            path: `/private/users/security/recovery-codes`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: ChangeUserEmailWithOtpInputToJSON(requestParameters['changeUserEmailWithOtpInput']),
         }, initOverrides);
 
-        return new runtime.VoidApiResponse(response);
+        return new runtime.JSONApiResponse(response, (jsonValue) => 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
      */
-    async changeUserEmailWithOtp(requestParameters: UsersApiChangeUserEmailWithOtpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
-        await this.changeUserEmailWithOtpRaw(requestParameters, initOverrides);
+    async regenerateUserRecoveryCodes(requestParameters: UsersApiRegenerateUserRecoveryCodesRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<RecoveryCodesDto> {
+        const response = await this.regenerateUserRecoveryCodesRaw(requestParameters, initOverrides);
+        return await response.value();
     }
 
     /**
-     * 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
      */
-    async getUserNotificationSettingsRaw(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserNotificationSettingsDto>> {
+    async registerUserPasskeyRaw(requestParameters: UsersApiRegisterUserPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        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().'
+            );
+        }
+
         const queryParameters: any = {};
 
         const headerParameters: runtime.HTTPHeaders = {};
 
-        if (this.configuration && this.configuration.apiKey) {
-            headerParameters["apikey"] = await this.configuration.apiKey("apikey"); // api_key authentication
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (requestParameters['xReauthenticationToken'] != null) {
+            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
         }
 
         if (this.configuration && this.configuration.accessToken) {
@@ -140,22 +1115,22 @@ export class UsersApi extends runtime.BaseAPI {
             }
         }
         const response = await this.request({
-            path: `/private/users/notification-settings`,
-            method: 'GET',
+            path: `/private/users/security/passkeys`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: RegisterUserPasskeyInputToJSON(requestParameters['registerUserPasskeyInput']),
         }, initOverrides);
 
-        return new runtime.JSONApiResponse(response, (jsonValue) => UserNotificationSettingsDtoFromJSON(jsonValue));
+        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
      */
-    async getUserNotificationSettings(initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserNotificationSettingsDto> {
-        const response = await this.getUserNotificationSettingsRaw(initOverrides);
-        return await response.value();
+    async registerUserPasskey(requestParameters: UsersApiRegisterUserPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.registerUserPasskeyRaw(requestParameters, initOverrides);
     }
 
     /**
@@ -203,6 +1178,58 @@ export class UsersApi extends runtime.BaseAPI {
         await this.registerUserPushTokenRaw(requestParameters, initOverrides);
     }
 
+    /**
+     * Needs that very passkey, used one last time (see the verification options).
+     * Remove a passkey
+     */
+    async removeUserPasskeyRaw(requestParameters: UsersApiRemoveUserPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        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().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/passkeys/{passkeyId}`.replace(`{${"passkeyId"}}`, encodeURIComponent(String(requestParameters['passkeyId']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+            body: RemoveUserPasskeyInputToJSON(requestParameters['removeUserPasskeyInput']),
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Needs that very passkey, used one last time (see the verification options).
+     * Remove a passkey
+     */
+    async removeUserPasskey(requestParameters: UsersApiRemoveUserPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.removeUserPasskeyRaw(requestParameters, initOverrides);
+    }
+
     /**
      * Unregisters an Expo push token for the current user, e.g. on logout. Seller session only.
      * Remove a push token
@@ -245,6 +1272,56 @@ export class UsersApi extends runtime.BaseAPI {
         await this.removeUserPushTokenRaw(requestParameters, initOverrides);
     }
 
+    /**
+     * Rename a passkey
+     */
+    async renameUserPasskeyRaw(requestParameters: UsersApiRenameUserPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>> {
+        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().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        headerParameters['Content-Type'] = 'application/json';
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/passkeys/{passkeyId}`.replace(`{${"passkeyId"}}`, encodeURIComponent(String(requestParameters['passkeyId']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: RenameUserPasskeyInputToJSON(requestParameters['renameUserPasskeyInput']),
+        }, initOverrides);
+
+        return new runtime.VoidApiResponse(response);
+    }
+
+    /**
+     * Rename a passkey
+     */
+    async renameUserPasskey(requestParameters: UsersApiRenameUserPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void> {
+        await this.renameUserPasskeyRaw(requestParameters, initOverrides);
+    }
+
     /**
      * 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
@@ -343,6 +1420,100 @@ export class UsersApi extends runtime.BaseAPI {
         await this.setLocaleRaw(requestParameters, initOverrides);
     }
 
+    /**
+     * 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
+     */
+    async startUserTotpEnrolmentRaw(requestParameters: UsersApiStartUserTotpEnrolmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TotpEnrolmentDto>> {
+        if (requestParameters['xReauthenticationToken'] == null) {
+            throw new runtime.RequiredError(
+                'xReauthenticationToken',
+                'Required parameter "xReauthenticationToken" was null or undefined when calling startUserTotpEnrolment().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xReauthenticationToken'] != null) {
+            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/totp`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => 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
+     */
+    async startUserTotpEnrolment(requestParameters: UsersApiStartUserTotpEnrolmentRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TotpEnrolmentDto> {
+        const response = await this.startUserTotpEnrolmentRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
+    /**
+     * 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
+     */
+    async startUserTotpReplacementRaw(requestParameters: UsersApiStartUserTotpReplacementRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<TotpEnrolmentDto>> {
+        if (requestParameters['xReauthenticationToken'] == null) {
+            throw new runtime.RequiredError(
+                'xReauthenticationToken',
+                'Required parameter "xReauthenticationToken" was null or undefined when calling startUserTotpReplacement().'
+            );
+        }
+
+        const queryParameters: any = {};
+
+        const headerParameters: runtime.HTTPHeaders = {};
+
+        if (requestParameters['xReauthenticationToken'] != null) {
+            headerParameters['x-reauthentication-token'] = String(requestParameters['xReauthenticationToken']);
+        }
+
+        if (this.configuration && this.configuration.accessToken) {
+            const token = this.configuration.accessToken;
+            const tokenString = await token("bearer", []);
+
+            if (tokenString) {
+                headerParameters["Authorization"] = `Bearer ${tokenString}`;
+            }
+        }
+        const response = await this.request({
+            path: `/private/users/security/totp/replace`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+
+        return new runtime.JSONApiResponse(response, (jsonValue) => 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
+     */
+    async startUserTotpReplacement(requestParameters: UsersApiStartUserTotpReplacementRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<TotpEnrolmentDto> {
+        const response = await this.startUserTotpReplacementRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+
     /**
      * 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