@randock/nameshift-api-client 0.0.503 → 0.0.505

package/dist/apis/UsersPublicApi.d.ts

@@ -10,16 +10,45 @@
  * Do not edit the class manually.
  */
 import * as runtime from '../runtime';
-import type { ForgotPasswordRequestInput, LoginDto, LoginInput, NotificationsUnsubscribeResultDto, SetNewPasswordInput, UserPasswordResetDto, UserSignedTokenInput } from '../models/index';
+import type { ConfirmLoginLocationInput, ForgotPasswordRequestInput, LoginChallengeInput, LoginCodeInput, LoginDto, LoginInput, LoginPasskeyInput, LoginPasskeyOptionsInput, LoginPasswordInput, LoginRecoveryCodeInput, NotificationsUnsubscribeResultDto, PasskeyOptionsDto, SetNewPasswordInput, UserLoginLocationConfirmationDetailsDto, UserPasswordResetDto, UserSignedTokenInput } from '../models/index';
+export interface UsersPublicApiConfirmLoginLocationRequest {
+    confirmationId: string;
+    confirmLoginLocationInput: ConfirmLoginLocationInput;
+}
 export interface UsersPublicApiForgotPasswordRequestRequest {
     forgotPasswordRequestInput: ForgotPasswordRequestInput;
 }
 export interface UsersPublicApiGetForgotPasswordRequestRequest {
     passwordRequestId: string;
 }
+export interface UsersPublicApiGetLoginLocationConfirmationDetailsRequest {
+    confirmationId: string;
+    confirmLoginLocationInput: ConfirmLoginLocationInput;
+}
+export interface UsersPublicApiGetLoginLocationConfirmationStatusRequest {
+    loginChallengeInput: LoginChallengeInput;
+}
+export interface UsersPublicApiGetLoginPasskeyOptionsRequest {
+    loginPasskeyOptionsInput: LoginPasskeyOptionsInput;
+}
 export interface UsersPublicApiLoginRequest {
     loginInput: LoginInput;
 }
+export interface UsersPublicApiLoginWithPasskeyRequest {
+    loginPasskeyInput: LoginPasskeyInput;
+}
+export interface UsersPublicApiLoginWithPasswordStepRequest {
+    loginPasswordInput: LoginPasswordInput;
+}
+export interface UsersPublicApiLoginWithRecoveryCodeRequest {
+    loginCodeInput: LoginCodeInput;
+}
+export interface UsersPublicApiLoginWithRecoveryCodeInsteadOfPasskeyRequest {
+    loginRecoveryCodeInput: LoginRecoveryCodeInput;
+}
+export interface UsersPublicApiLoginWithTotpRequest {
+    loginCodeInput: LoginCodeInput;
+}
 export interface UsersPublicApiPostNewPasswordRequest {
     passwordRequestId: string;
     setNewPasswordInput: SetNewPasswordInput;
@@ -31,6 +60,16 @@ export interface UsersPublicApiUnsubscribeFromNotificationsByTokenRequest {
  *
  */
 export declare class UsersPublicApi extends runtime.BaseAPI {
+    /**
+     * Called by the page the email links to. It only approves the sign-in: no session is returned here.
+     * Approve a sign-in from a new location
+     */
+    confirmLoginLocationRaw(requestParameters: UsersPublicApiConfirmLoginLocationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<void>>;
+    /**
+     * Called by the page the email links to. It only approves the sign-in: no session is returned here.
+     * Approve a sign-in from a new location
+     */
+    confirmLoginLocation(requestParameters: UsersPublicApiConfirmLoginLocationRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<void>;
     /**
      * Creates a password reset request and sends a reset link to the provided email address.
      * Request a password reset email
@@ -52,15 +91,93 @@ export declare class UsersPublicApi extends runtime.BaseAPI {
      */
     getForgotPasswordRequest(requestParameters: UsersPublicApiGetForgotPasswordRequestRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserPasswordResetDto>;
     /**
-     * Validates email and password credentials and returns a JWT token with the user locale.
+     * Approves nothing: the page the email links to shows these details and approves only when the user says so, so that mail scanners opening the link approve nothing.
+     * See the sign-in an email link asks to approve
+     */
+    getLoginLocationConfirmationDetailsRaw(requestParameters: UsersPublicApiGetLoginLocationConfirmationDetailsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<UserLoginLocationConfirmationDetailsDto>>;
+    /**
+     * Approves nothing: the page the email links to shows these details and approves only when the user says so, so that mail scanners opening the link approve nothing.
+     * See the sign-in an email link asks to approve
+     */
+    getLoginLocationConfirmationDetails(requestParameters: UsersPublicApiGetLoginLocationConfirmationDetailsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<UserLoginLocationConfirmationDetailsDto>;
+    /**
+     * Polled by the browser that started the sign-in. It, and only it, gets the session once the user opens the link in the email.
+     * Wait for the email confirming a new location
+     */
+    getLoginLocationConfirmationStatusRaw(requestParameters: UsersPublicApiGetLoginLocationConfirmationStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LoginDto>>;
+    /**
+     * Polled by the browser that started the sign-in. It, and only it, gets the session once the user opens the link in the email.
+     * Wait for the email confirming a new location
+     */
+    getLoginLocationConfirmationStatus(requestParameters: UsersPublicApiGetLoginLocationConfirmationStatusRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LoginDto>;
+    /**
+     * Without a challenge token, any passkey of the site on the device can answer, for users whose first sign-in step accepts a passkey. With one, the passkey proves the next step of that sign-in.
+     * Start signing in with a passkey
+     */
+    getLoginPasskeyOptionsRaw(requestParameters: UsersPublicApiGetLoginPasskeyOptionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<PasskeyOptionsDto>>;
+    /**
+     * Without a challenge token, any passkey of the site on the device can answer, for users whose first sign-in step accepts a passkey. With one, the passkey proves the next step of that sign-in.
+     * Start signing in with a passkey
+     */
+    getLoginPasskeyOptions(requestParameters: UsersPublicApiGetLoginPasskeyOptionsRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<PasskeyOptionsDto>;
+    /**
+     * Validates email and password. Returns the session token, or a challenge token and the next step: a second factor, setting up an authenticator app, or confirming a new location by email.
      * Authenticate a seller user
      */
     loginRaw(requestParameters: UsersPublicApiLoginRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LoginDto>>;
     /**
-     * Validates email and password credentials and returns a JWT token with the user locale.
+     * Validates email and password. Returns the session token, or a challenge token and the next step: a second factor, setting up an authenticator app, or confirming a new location by email.
      * Authenticate a seller user
      */
     login(requestParameters: UsersPublicApiLoginRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LoginDto>;
+    /**
+     * Sign in with a passkey, or prove a later step with one
+     */
+    loginWithPasskeyRaw(requestParameters: UsersPublicApiLoginWithPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LoginDto>>;
+    /**
+     * Sign in with a passkey, or prove a later step with one
+     */
+    loginWithPasskey(requestParameters: UsersPublicApiLoginWithPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LoginDto>;
+    /**
+     * For users who enter the password after another step, e.g. a passkey first. Wrong passwords count towards the lock of the later steps.
+     * Prove a later sign-in step with the password
+     */
+    loginWithPasswordStepRaw(requestParameters: UsersPublicApiLoginWithPasswordStepRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LoginDto>>;
+    /**
+     * For users who enter the password after another step, e.g. a passkey first. Wrong passwords count towards the lock of the later steps.
+     * Prove a later sign-in step with the password
+     */
+    loginWithPasswordStep(requestParameters: UsersPublicApiLoginWithPasswordStepRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LoginDto>;
+    /**
+     * Each recovery code works once.
+     * Prove the second factor with a recovery code
+     */
+    loginWithRecoveryCodeRaw(requestParameters: UsersPublicApiLoginWithRecoveryCodeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LoginDto>>;
+    /**
+     * Each recovery code works once.
+     * Prove the second factor with a recovery code
+     */
+    loginWithRecoveryCode(requestParameters: UsersPublicApiLoginWithRecoveryCodeRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LoginDto>;
+    /**
+     * For users whose first sign-in step is a passkey alone: the recovery code stands in for it, and the next steps are still asked for. Users who can start with the password enter it first, then the recovery code in a later step; here they get the same error as for a wrong code.
+     * Sign in with a recovery code instead of a lost passkey
+     */
+    loginWithRecoveryCodeInsteadOfPasskeyRaw(requestParameters: UsersPublicApiLoginWithRecoveryCodeInsteadOfPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LoginDto>>;
+    /**
+     * For users whose first sign-in step is a passkey alone: the recovery code stands in for it, and the next steps are still asked for. Users who can start with the password enter it first, then the recovery code in a later step; here they get the same error as for a wrong code.
+     * Sign in with a recovery code instead of a lost passkey
+     */
+    loginWithRecoveryCodeInsteadOfPasskey(requestParameters: UsersPublicApiLoginWithRecoveryCodeInsteadOfPasskeyRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LoginDto>;
+    /**
+     * Accepts the code of the current period, the previous or the next one, never twice.
+     * Prove the second factor with an authenticator app code
+     */
+    loginWithTotpRaw(requestParameters: UsersPublicApiLoginWithTotpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<runtime.ApiResponse<LoginDto>>;
+    /**
+     * Accepts the code of the current period, the previous or the next one, never twice.
+     * Prove the second factor with an authenticator app code
+     */
+    loginWithTotp(requestParameters: UsersPublicApiLoginWithTotpRequest, initOverrides?: RequestInit | runtime.InitOverrideFunction): Promise<LoginDto>;
     /**
      * Completes the password reset flow by setting a new password for the user linked to the reset request.
      * Set a new password from reset request

package/dist/apis/UsersPublicApi.js

@@ -75,6 +75,55 @@ var UsersPublicApi = /** @class */ (function (_super) {
     function UsersPublicApi() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * Called by the page the email links to. It only approves the sign-in: no session is returned here.
+     * Approve a sign-in from a new location
+     */
+    UsersPublicApi.prototype.confirmLoginLocationRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['confirmationId'] == null) {
+                            throw new runtime.RequiredError('confirmationId', 'Required parameter "confirmationId" was null or undefined when calling confirmLoginLocation().');
+                        }
+                        if (requestParameters['confirmLoginLocationInput'] == null) {
+                            throw new runtime.RequiredError('confirmLoginLocationInput', 'Required parameter "confirmLoginLocationInput" was null or undefined when calling confirmLoginLocation().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        return [4 /*yield*/, this.request({
+                                path: "/users/login/location-confirmation/{confirmationId}/confirm".replace("{".concat("confirmationId", "}"), encodeURIComponent(String(requestParameters['confirmationId']))),
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.ConfirmLoginLocationInputToJSON)(requestParameters['confirmLoginLocationInput']),
+                            }, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     * Called by the page the email links to. It only approves the sign-in: no session is returned here.
+     * Approve a sign-in from a new location
+     */
+    UsersPublicApi.prototype.confirmLoginLocation = 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.confirmLoginLocationRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
     /**
      * Creates a password reset request and sends a reset link to the provided email address.
      * Request a password reset email
@@ -168,7 +217,154 @@ var UsersPublicApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Validates email and password credentials and returns a JWT token with the user locale.
+     * Approves nothing: the page the email links to shows these details and approves only when the user says so, so that mail scanners opening the link approve nothing.
+     * See the sign-in an email link asks to approve
+     */
+    UsersPublicApi.prototype.getLoginLocationConfirmationDetailsRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['confirmationId'] == null) {
+                            throw new runtime.RequiredError('confirmationId', 'Required parameter "confirmationId" was null or undefined when calling getLoginLocationConfirmationDetails().');
+                        }
+                        if (requestParameters['confirmLoginLocationInput'] == null) {
+                            throw new runtime.RequiredError('confirmLoginLocationInput', 'Required parameter "confirmLoginLocationInput" was null or undefined when calling getLoginLocationConfirmationDetails().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        return [4 /*yield*/, this.request({
+                                path: "/users/login/location-confirmation/{confirmationId}/details".replace("{".concat("confirmationId", "}"), encodeURIComponent(String(requestParameters['confirmationId']))),
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.ConfirmLoginLocationInputToJSON)(requestParameters['confirmLoginLocationInput']),
+                            }, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.UserLoginLocationConfirmationDetailsDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Approves nothing: the page the email links to shows these details and approves only when the user says so, so that mail scanners opening the link approve nothing.
+     * See the sign-in an email link asks to approve
+     */
+    UsersPublicApi.prototype.getLoginLocationConfirmationDetails = 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.getLoginLocationConfirmationDetailsRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Polled by the browser that started the sign-in. It, and only it, gets the session once the user opens the link in the email.
+     * Wait for the email confirming a new location
+     */
+    UsersPublicApi.prototype.getLoginLocationConfirmationStatusRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['loginChallengeInput'] == null) {
+                            throw new runtime.RequiredError('loginChallengeInput', 'Required parameter "loginChallengeInput" was null or undefined when calling getLoginLocationConfirmationStatus().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        return [4 /*yield*/, this.request({
+                                path: "/users/login/location-confirmation/status",
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.LoginChallengeInputToJSON)(requestParameters['loginChallengeInput']),
+                            }, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.LoginDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Polled by the browser that started the sign-in. It, and only it, gets the session once the user opens the link in the email.
+     * Wait for the email confirming a new location
+     */
+    UsersPublicApi.prototype.getLoginLocationConfirmationStatus = 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.getLoginLocationConfirmationStatusRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Without a challenge token, any passkey of the site on the device can answer, for users whose first sign-in step accepts a passkey. With one, the passkey proves the next step of that sign-in.
+     * Start signing in with a passkey
+     */
+    UsersPublicApi.prototype.getLoginPasskeyOptionsRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['loginPasskeyOptionsInput'] == null) {
+                            throw new runtime.RequiredError('loginPasskeyOptionsInput', 'Required parameter "loginPasskeyOptionsInput" was null or undefined when calling getLoginPasskeyOptions().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        return [4 /*yield*/, this.request({
+                                path: "/users/login/passkey/options",
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.LoginPasskeyOptionsInputToJSON)(requestParameters['loginPasskeyOptionsInput']),
+                            }, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.PasskeyOptionsDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Without a challenge token, any passkey of the site on the device can answer, for users whose first sign-in step accepts a passkey. With one, the passkey proves the next step of that sign-in.
+     * Start signing in with a passkey
+     */
+    UsersPublicApi.prototype.getLoginPasskeyOptions = 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.getLoginPasskeyOptionsRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Validates email and password. Returns the session token, or a challenge token and the next step: a second factor, setting up an authenticator app, or confirming a new location by email.
      * Authenticate a seller user
      */
     UsersPublicApi.prototype.loginRaw = function (requestParameters, initOverrides) {
@@ -198,7 +394,7 @@ var UsersPublicApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Validates email and password credentials and returns a JWT token with the user locale.
+     * Validates email and password. Returns the session token, or a challenge token and the next step: a second factor, setting up an authenticator app, or confirming a new location by email.
      * Authenticate a seller user
      */
     UsersPublicApi.prototype.login = function (requestParameters, initOverrides) {
@@ -215,6 +411,244 @@ var UsersPublicApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Sign in with a passkey, or prove a later step with one
+     */
+    UsersPublicApi.prototype.loginWithPasskeyRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['loginPasskeyInput'] == null) {
+                            throw new runtime.RequiredError('loginPasskeyInput', 'Required parameter "loginPasskeyInput" was null or undefined when calling loginWithPasskey().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        return [4 /*yield*/, this.request({
+                                path: "/users/login/passkey",
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.LoginPasskeyInputToJSON)(requestParameters['loginPasskeyInput']),
+                            }, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.LoginDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Sign in with a passkey, or prove a later step with one
+     */
+    UsersPublicApi.prototype.loginWithPasskey = 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.loginWithPasskeyRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * For users who enter the password after another step, e.g. a passkey first. Wrong passwords count towards the lock of the later steps.
+     * Prove a later sign-in step with the password
+     */
+    UsersPublicApi.prototype.loginWithPasswordStepRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['loginPasswordInput'] == null) {
+                            throw new runtime.RequiredError('loginPasswordInput', 'Required parameter "loginPasswordInput" was null or undefined when calling loginWithPasswordStep().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        return [4 /*yield*/, this.request({
+                                path: "/users/login/password",
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.LoginPasswordInputToJSON)(requestParameters['loginPasswordInput']),
+                            }, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.LoginDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * For users who enter the password after another step, e.g. a passkey first. Wrong passwords count towards the lock of the later steps.
+     * Prove a later sign-in step with the password
+     */
+    UsersPublicApi.prototype.loginWithPasswordStep = 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.loginWithPasswordStepRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Each recovery code works once.
+     * Prove the second factor with a recovery code
+     */
+    UsersPublicApi.prototype.loginWithRecoveryCodeRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['loginCodeInput'] == null) {
+                            throw new runtime.RequiredError('loginCodeInput', 'Required parameter "loginCodeInput" was null or undefined when calling loginWithRecoveryCode().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        return [4 /*yield*/, this.request({
+                                path: "/users/login/recovery-code",
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.LoginCodeInputToJSON)(requestParameters['loginCodeInput']),
+                            }, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.LoginDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Each recovery code works once.
+     * Prove the second factor with a recovery code
+     */
+    UsersPublicApi.prototype.loginWithRecoveryCode = 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.loginWithRecoveryCodeRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * For users whose first sign-in step is a passkey alone: the recovery code stands in for it, and the next steps are still asked for. Users who can start with the password enter it first, then the recovery code in a later step; here they get the same error as for a wrong code.
+     * Sign in with a recovery code instead of a lost passkey
+     */
+    UsersPublicApi.prototype.loginWithRecoveryCodeInsteadOfPasskeyRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['loginRecoveryCodeInput'] == null) {
+                            throw new runtime.RequiredError('loginRecoveryCodeInput', 'Required parameter "loginRecoveryCodeInput" was null or undefined when calling loginWithRecoveryCodeInsteadOfPasskey().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        return [4 /*yield*/, this.request({
+                                path: "/users/login/recovery-code-instead-of-passkey",
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.LoginRecoveryCodeInputToJSON)(requestParameters['loginRecoveryCodeInput']),
+                            }, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.LoginDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * For users whose first sign-in step is a passkey alone: the recovery code stands in for it, and the next steps are still asked for. Users who can start with the password enter it first, then the recovery code in a later step; here they get the same error as for a wrong code.
+     * Sign in with a recovery code instead of a lost passkey
+     */
+    UsersPublicApi.prototype.loginWithRecoveryCodeInsteadOfPasskey = 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.loginWithRecoveryCodeInsteadOfPasskeyRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Accepts the code of the current period, the previous or the next one, never twice.
+     * Prove the second factor with an authenticator app code
+     */
+    UsersPublicApi.prototype.loginWithTotpRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0:
+                        if (requestParameters['loginCodeInput'] == null) {
+                            throw new runtime.RequiredError('loginCodeInput', 'Required parameter "loginCodeInput" was null or undefined when calling loginWithTotp().');
+                        }
+                        queryParameters = {};
+                        headerParameters = {};
+                        headerParameters['Content-Type'] = 'application/json';
+                        return [4 /*yield*/, this.request({
+                                path: "/users/login/totp",
+                                method: 'POST',
+                                headers: headerParameters,
+                                query: queryParameters,
+                                body: (0, index_1.LoginCodeInputToJSON)(requestParameters['loginCodeInput']),
+                            }, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, index_1.LoginDtoFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     * Accepts the code of the current period, the previous or the next one, never twice.
+     * Prove the second factor with an authenticator app code
+     */
+    UsersPublicApi.prototype.loginWithTotp = 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.loginWithTotpRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Completes the password reset flow by setting a new password for the user linked to the reset request.
      * Set a new password from reset request

package/dist/models/ActivateUserTotpInput.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Nameshift
+ * Nameshift domain marketplace and management API.  ## Authentication - **Bearer JWT** — Seller and buyer sessions obtained via login endpoints. - **API key** — Pass the `apikey` header for programmatic seller access.  ## Audiences - **(public)** tags — Unauthenticated or buyer-facing endpoints. - **Accounts / Domains / Leads / Buyers** — Seller or buyer resources. - **Partner** — Partner integrations.
+ *
+ * The version of the OpenAPI document: 1.0
+ *
+ *
+ * NOTE: This class is auto generated by OpenAPI Generator (https://openapi-generator.tech).
+ * https://openapi-generator.tech
+ * Do not edit the class manually.
+ */
+/**
+ *
+ * @export
+ * @interface ActivateUserTotpInput
+ */
+export interface ActivateUserTotpInput {
+    /**
+     * Code the authenticator app shows, to prove it was set up.
+     * @type {string}
+     * @memberof ActivateUserTotpInput
+     */
+    code: string;
+}
+/**
+ * Check if a given object implements the ActivateUserTotpInput interface.
+ */
+export declare function instanceOfActivateUserTotpInput(value: object): value is ActivateUserTotpInput;
+export declare function ActivateUserTotpInputFromJSON(json: any): ActivateUserTotpInput;
+export declare function ActivateUserTotpInputFromJSONTyped(json: any, ignoreDiscriminator: boolean): ActivateUserTotpInput;
+export declare function ActivateUserTotpInputToJSON(json: any): ActivateUserTotpInput;
+export declare function ActivateUserTotpInputToJSONTyped(value?: ActivateUserTotpInput | null, ignoreDiscriminator?: boolean): any;