@forteplatforms/sdk 1.0.169 → 1.0.245

package/dist/generated/apis/UsersServerApi.js

@@ -66,7 +66,9 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.UsersServerApi = void 0;
 var runtime = require("../runtime");
+var ActivateMfaMethodRequest_1 = require("../models/ActivateMfaMethodRequest");
 var AddContactMethodRequest_1 = require("../models/AddContactMethodRequest");
+var BackupCodesResponse_1 = require("../models/BackupCodesResponse");
 var ChangePasswordRequest_1 = require("../models/ChangePasswordRequest");
 var CompleteOtpLoginRequest_1 = require("../models/CompleteOtpLoginRequest");
 var CompletePasswordResetRequest_1 = require("../models/CompletePasswordResetRequest");
@@ -74,25 +76,43 @@ var ContactMethod_1 = require("../models/ContactMethod");
 var ContentObject_1 = require("../models/ContentObject");
 var CreateContentUploadLinkRequest_1 = require("../models/CreateContentUploadLinkRequest");
 var CreateContentUploadLinkResponse_1 = require("../models/CreateContentUploadLinkResponse");
+var CreateMfaMethodRequest_1 = require("../models/CreateMfaMethodRequest");
+var CreateMfaMethodResponse_1 = require("../models/CreateMfaMethodResponse");
 var CreateOtpLoginRequest_1 = require("../models/CreateOtpLoginRequest");
 var CreateOtpLoginResponse_1 = require("../models/CreateOtpLoginResponse");
+var CreatePaymentMethodResponse_1 = require("../models/CreatePaymentMethodResponse");
 var CreatePaymentPreviewRequest_1 = require("../models/CreatePaymentPreviewRequest");
 var CreatePaymentPreviewResponse_1 = require("../models/CreatePaymentPreviewResponse");
 var CreatePaymentRequest_1 = require("../models/CreatePaymentRequest");
 var CreatePaymentResponse_1 = require("../models/CreatePaymentResponse");
+var CreateSubscriptionPreviewRequest_1 = require("../models/CreateSubscriptionPreviewRequest");
+var CreateSubscriptionPreviewResponse_1 = require("../models/CreateSubscriptionPreviewResponse");
+var CreateSubscriptionRequest_1 = require("../models/CreateSubscriptionRequest");
+var CreateSubscriptionResponse_1 = require("../models/CreateSubscriptionResponse");
 var CreateUserInviteRequest_1 = require("../models/CreateUserInviteRequest");
 var GetContentDownloadLinkResponse_1 = require("../models/GetContentDownloadLinkResponse");
 var ListContentResponse_1 = require("../models/ListContentResponse");
+var ListMfaMethodsResponse_1 = require("../models/ListMfaMethodsResponse");
 var ListUserInvitesResponse_1 = require("../models/ListUserInvitesResponse");
 var LoginUserResponse_1 = require("../models/LoginUserResponse");
+var MfaChallengeRequest_1 = require("../models/MfaChallengeRequest");
+var MfaChallengeResponse_1 = require("../models/MfaChallengeResponse");
+var MfaVerifyRequest_1 = require("../models/MfaVerifyRequest");
 var PaginatedResponsePaymentObject_1 = require("../models/PaginatedResponsePaymentObject");
 var PasswordLoginRequest_1 = require("../models/PasswordLoginRequest");
+var PaymentMethodObject_1 = require("../models/PaymentMethodObject");
 var PendingUserInviteObject_1 = require("../models/PendingUserInviteObject");
 var RegisterUserRequest_1 = require("../models/RegisterUserRequest");
 var RegisterUserResponse_1 = require("../models/RegisterUserResponse");
+var RenameMfaMethodRequest_1 = require("../models/RenameMfaMethodRequest");
 var RenewSessionTokenResponse_1 = require("../models/RenewSessionTokenResponse");
 var RequestPasswordResetRequest_1 = require("../models/RequestPasswordResetRequest");
+var SubscriptionObject_1 = require("../models/SubscriptionObject");
+var UpdateContentOwnerRequest_1 = require("../models/UpdateContentOwnerRequest");
 var UpdateContentSharesRequest_1 = require("../models/UpdateContentSharesRequest");
+var UpdatePaymentMethodRequest_1 = require("../models/UpdatePaymentMethodRequest");
+var UpdateSubscriptionPreviewRequest_1 = require("../models/UpdateSubscriptionPreviewRequest");
+var UpdateSubscriptionRequest_1 = require("../models/UpdateSubscriptionRequest");
 var UserObject_1 = require("../models/UserObject");
 /**
  *
@@ -102,6 +122,131 @@ var UsersServerApi = /** @class */ (function (_super) {
     function UsersServerApi() {
         return _super !== null && _super.apply(this, arguments) || this;
     }
+    /**
+     * Creates request options for activateMfaMethod without sending the request
+     */
+    UsersServerApi.prototype.activateMfaMethodRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling activateMfaMethod().');
+                }
+                if (requestParameters['mfaMethodId'] == null) {
+                    throw new runtime.RequiredError('mfaMethodId', 'Required parameter "mfaMethodId" was null or undefined when calling activateMfaMethod().');
+                }
+                if (requestParameters['activateMfaMethodRequest'] == null) {
+                    throw new runtime.RequiredError('activateMfaMethodRequest', 'Required parameter "activateMfaMethodRequest" was null or undefined when calling activateMfaMethod().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/mfa/methods/{mfaMethodId}/verification";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{mfaMethodId}', encodeURIComponent(String(requestParameters['mfaMethodId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, ActivateMfaMethodRequest_1.ActivateMfaMethodRequestToJSON)(requestParameters['activateMfaMethodRequest']),
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.activateMfaMethodRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.activateMfaMethodRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.activateMfaMethod = 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.activateMfaMethodRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for cancelMySubscription without sending the request
+     */
+    UsersServerApi.prototype.cancelMySubscriptionRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling cancelMySubscription().');
+                }
+                if (requestParameters['subscriptionId'] == null) {
+                    throw new runtime.RequiredError('subscriptionId', 'Required parameter "subscriptionId" was null or undefined when calling cancelMySubscription().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/api/v1/{projectId}/users/me/subscriptions/{subscriptionId}";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{subscriptionId}', encodeURIComponent(String(requestParameters['subscriptionId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'DELETE',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.cancelMySubscriptionRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.cancelMySubscriptionRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, SubscriptionObject_1.SubscriptionObjectFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.cancelMySubscription = 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.cancelMySubscriptionRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Creates request options for changeMyPassword without sending the request
      */
@@ -352,6 +497,68 @@ var UsersServerApi = /** @class */ (function (_super) {
             });
         });
     };
+    /**
+     * Creates request options for createMfaMethod without sending the request
+     */
+    UsersServerApi.prototype.createMfaMethodRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling createMfaMethod().');
+                }
+                if (requestParameters['createMfaMethodRequest'] == null) {
+                    throw new runtime.RequiredError('createMfaMethodRequest', 'Required parameter "createMfaMethodRequest" was null or undefined when calling createMfaMethod().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/mfa/methods";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, CreateMfaMethodRequest_1.CreateMfaMethodRequestToJSON)(requestParameters['createMfaMethodRequest']),
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.createMfaMethodRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.createMfaMethodRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreateMfaMethodResponse_1.CreateMfaMethodResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.createMfaMethod = 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.createMfaMethodRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
     /**
      * Creates request options for createOtpLogin without sending the request
      */
@@ -536,22 +743,26 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for getAccount without sending the request
+     * Creates request options for deleteMfaMethod without sending the request
      */
-    UsersServerApi.prototype.getAccountRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.deleteMfaMethodRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling getAccount().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling deleteMfaMethod().');
+                }
+                if (requestParameters['mfaMethodId'] == null) {
+                    throw new runtime.RequiredError('mfaMethodId', 'Required parameter "mfaMethodId" was null or undefined when calling deleteMfaMethod().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/me";
+                urlPath = "/api/v1/{projectId}/users/me/mfa/methods/{mfaMethodId}";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{mfaMethodId}', encodeURIComponent(String(requestParameters['mfaMethodId'])));
                 return [2 /*return*/, {
                         path: urlPath,
-                        method: 'GET',
+                        method: 'DELETE',
                         headers: headerParameters,
                         query: queryParameters,
                     }];
@@ -560,114 +771,85 @@ var UsersServerApi = /** @class */ (function (_super) {
     };
     /**
      */
-    UsersServerApi.prototype.getAccountRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.deleteMfaMethodRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.getAccountRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.deleteMfaMethodRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, UserObject_1.UserObjectFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.getAccount = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.deleteMfaMethod = 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.getAccountRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.deleteMfaMethodRaw(requestParameters, initOverrides)];
                     case 1:
-                        response = _a.sent();
-                        return [4 /*yield*/, response.value()];
-                    case 2: return [2 /*return*/, _a.sent()];
+                        _a.sent();
+                        return [2 /*return*/];
                 }
             });
         });
     };
     /**
-     * Creates request options for googleAuthLoginCallback without sending the request
+     * Creates request options for generateBackupCodes without sending the request
      */
-    UsersServerApi.prototype.googleAuthLoginCallbackRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.generateBackupCodesRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
-            var queryParameters, headerParameters, consumes, canConsumeForm, formParams, useForm, urlPath;
+            var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling googleAuthLoginCallback().');
-                }
-                if (requestParameters['gCsrfToken'] == null) {
-                    throw new runtime.RequiredError('gCsrfToken', 'Required parameter "gCsrfToken" was null or undefined when calling googleAuthLoginCallback().');
-                }
-                if (requestParameters['credential'] == null) {
-                    throw new runtime.RequiredError('credential', 'Required parameter "credential" was null or undefined when calling googleAuthLoginCallback().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling generateBackupCodes().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                consumes = [
-                    { contentType: 'application/x-www-form-urlencoded' },
-                ];
-                canConsumeForm = runtime.canConsumeForm(consumes);
-                useForm = false;
-                if (useForm) {
-                    formParams = new FormData();
-                }
-                else {
-                    formParams = new URLSearchParams();
-                }
-                if (requestParameters['gCsrfToken'] != null) {
-                    formParams.append('g_csrf_token', requestParameters['gCsrfToken']);
-                }
-                if (requestParameters['credential'] != null) {
-                    formParams.append('credential', requestParameters['credential']);
-                }
-                if (requestParameters['recaptchaToken'] != null) {
-                    formParams.append('recaptcha_token', requestParameters['recaptchaToken']);
-                }
-                urlPath = "/api/v1/{projectId}/users/google-auth-callback";
+                urlPath = "/api/v1/{projectId}/users/me/mfa/backup-codes";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
                 return [2 /*return*/, {
                         path: urlPath,
                         method: 'POST',
                         headers: headerParameters,
                         query: queryParameters,
-                        body: formParams,
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.googleAuthLoginCallbackRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.generateBackupCodesRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.googleAuthLoginCallbackRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.generateBackupCodesRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, LoginUserResponse_1.LoginUserResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, BackupCodesResponse_1.BackupCodesResponseFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.googleAuthLoginCallback = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.generateBackupCodes = 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.googleAuthLoginCallbackRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.generateBackupCodesRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -677,33 +859,18 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for listMyPayments without sending the request
+     * Creates request options for getAccount without sending the request
      */
-    UsersServerApi.prototype.listMyPaymentsRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.getAccountRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling listMyPayments().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling getAccount().');
                 }
                 queryParameters = {};
-                if (requestParameters['metadataKey'] != null) {
-                    queryParameters['metadataKey'] = requestParameters['metadataKey'];
-                }
-                if (requestParameters['metadataValue'] != null) {
-                    queryParameters['metadataValue'] = requestParameters['metadataValue'];
-                }
-                if (requestParameters['minTime'] != null) {
-                    queryParameters['minTime'] = requestParameters['minTime'].toISOString();
-                }
-                if (requestParameters['maxTime'] != null) {
-                    queryParameters['maxTime'] = requestParameters['maxTime'].toISOString();
-                }
-                if (requestParameters['nextToken'] != null) {
-                    queryParameters['nextToken'] = requestParameters['nextToken'];
-                }
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/me/payments";
+                urlPath = "/api/v1/{projectId}/users/me";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
                 return [2 /*return*/, {
                         path: urlPath,
@@ -716,30 +883,30 @@ var UsersServerApi = /** @class */ (function (_super) {
     };
     /**
      */
-    UsersServerApi.prototype.listMyPaymentsRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.getAccountRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.listMyPaymentsRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.getAccountRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, PaginatedResponsePaymentObject_1.PaginatedResponsePaymentObjectFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, UserObject_1.UserObjectFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.listMyPayments = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.getAccount = 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.listMyPaymentsRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.getAccountRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -749,18 +916,18 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for listUserInvites without sending the request
+     * Creates request options for getBackupCodeStatus without sending the request
      */
-    UsersServerApi.prototype.listUserInvitesRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.getBackupCodeStatusRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling listUserInvites().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling getBackupCodeStatus().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/me/invites";
+                urlPath = "/api/v1/{projectId}/users/me/mfa/backup-codes";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
                 return [2 /*return*/, {
                         path: urlPath,
@@ -773,30 +940,30 @@ var UsersServerApi = /** @class */ (function (_super) {
     };
     /**
      */
-    UsersServerApi.prototype.listUserInvitesRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.getBackupCodeStatusRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.listUserInvitesRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.getBackupCodeStatusRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ListUserInvitesResponse_1.ListUserInvitesResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, BackupCodesResponse_1.BackupCodesResponseFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.listUserInvites = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.getBackupCodeStatus = 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.listUserInvitesRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.getBackupCodeStatusRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -806,117 +973,1197 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for logout without sending the request
+     * Creates request options for getMySubscription without sending the request
      */
-    UsersServerApi.prototype.logoutRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.getMySubscriptionRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling logout().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling getMySubscription().');
+                }
+                if (requestParameters['subscriptionId'] == null) {
+                    throw new runtime.RequiredError('subscriptionId', 'Required parameter "subscriptionId" was null or undefined when calling getMySubscription().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                if (requestParameters['authorization'] != null) {
-                    headerParameters['Authorization'] = String(requestParameters['authorization']);
-                }
-                urlPath = "/api/v1/{projectId}/users/logout";
+                urlPath = "/api/v1/{projectId}/users/me/subscriptions/{subscriptionId}";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{subscriptionId}', encodeURIComponent(String(requestParameters['subscriptionId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.getMySubscriptionRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.getMySubscriptionRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, SubscriptionObject_1.SubscriptionObjectFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.getMySubscription = 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.getMySubscriptionRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for googleAuthLoginCallback without sending the request
+     */
+    UsersServerApi.prototype.googleAuthLoginCallbackRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, consumes, canConsumeForm, formParams, useForm, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling googleAuthLoginCallback().');
+                }
+                if (requestParameters['gCsrfToken'] == null) {
+                    throw new runtime.RequiredError('gCsrfToken', 'Required parameter "gCsrfToken" was null or undefined when calling googleAuthLoginCallback().');
+                }
+                if (requestParameters['credential'] == null) {
+                    throw new runtime.RequiredError('credential', 'Required parameter "credential" was null or undefined when calling googleAuthLoginCallback().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                consumes = [
+                    { contentType: 'application/x-www-form-urlencoded' },
+                ];
+                canConsumeForm = runtime.canConsumeForm(consumes);
+                useForm = false;
+                if (useForm) {
+                    formParams = new FormData();
+                }
+                else {
+                    formParams = new URLSearchParams();
+                }
+                if (requestParameters['gCsrfToken'] != null) {
+                    formParams.append('g_csrf_token', requestParameters['gCsrfToken']);
+                }
+                if (requestParameters['credential'] != null) {
+                    formParams.append('credential', requestParameters['credential']);
+                }
+                if (requestParameters['recaptchaToken'] != null) {
+                    formParams.append('recaptcha_token', requestParameters['recaptchaToken']);
+                }
+                urlPath = "/api/v1/{projectId}/users/google-auth-callback";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: formParams,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.googleAuthLoginCallbackRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.googleAuthLoginCallbackRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, LoginUserResponse_1.LoginUserResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.googleAuthLoginCallback = 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.googleAuthLoginCallbackRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for listMfaMethods without sending the request
+     */
+    UsersServerApi.prototype.listMfaMethodsRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling listMfaMethods().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/api/v1/{projectId}/users/me/mfa/methods";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.listMfaMethodsRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.listMfaMethodsRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ListMfaMethodsResponse_1.ListMfaMethodsResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.listMfaMethods = 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.listMfaMethodsRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for listMyPayments without sending the request
+     */
+    UsersServerApi.prototype.listMyPaymentsRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling listMyPayments().');
+                }
+                queryParameters = {};
+                if (requestParameters['metadataKey'] != null) {
+                    queryParameters['metadataKey'] = requestParameters['metadataKey'];
+                }
+                if (requestParameters['metadataValue'] != null) {
+                    queryParameters['metadataValue'] = requestParameters['metadataValue'];
+                }
+                if (requestParameters['minTime'] != null) {
+                    queryParameters['minTime'] = requestParameters['minTime'].toISOString();
+                }
+                if (requestParameters['maxTime'] != null) {
+                    queryParameters['maxTime'] = requestParameters['maxTime'].toISOString();
+                }
+                if (requestParameters['nextToken'] != null) {
+                    queryParameters['nextToken'] = requestParameters['nextToken'];
+                }
+                headerParameters = {};
+                urlPath = "/api/v1/{projectId}/users/me/payments";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.listMyPaymentsRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.listMyPaymentsRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, PaginatedResponsePaymentObject_1.PaginatedResponsePaymentObjectFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.listMyPayments = 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.listMyPaymentsRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for listMySubscriptions without sending the request
+     */
+    UsersServerApi.prototype.listMySubscriptionsRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling listMySubscriptions().');
+                }
+                queryParameters = {};
+                if (requestParameters['page'] != null) {
+                    queryParameters['page'] = requestParameters['page'];
+                }
+                if (requestParameters['pageSize'] != null) {
+                    queryParameters['pageSize'] = requestParameters['pageSize'];
+                }
+                headerParameters = {};
+                urlPath = "/api/v1/{projectId}/users/me/subscriptions";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.listMySubscriptionsRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.listMySubscriptionsRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return jsonValue.map(SubscriptionObject_1.SubscriptionObjectFromJSON); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.listMySubscriptions = 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.listMySubscriptionsRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for listUserInvites without sending the request
+     */
+    UsersServerApi.prototype.listUserInvitesRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling listUserInvites().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/api/v1/{projectId}/users/me/invites";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'GET',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.listUserInvitesRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.listUserInvitesRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ListUserInvitesResponse_1.ListUserInvitesResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.listUserInvites = 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.listUserInvitesRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for logout without sending the request
+     */
+    UsersServerApi.prototype.logoutRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling logout().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                if (requestParameters['authorization'] != null) {
+                    headerParameters['Authorization'] = String(requestParameters['authorization']);
+                }
+                urlPath = "/api/v1/{projectId}/users/logout";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.logoutRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.logoutRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.logout = 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.logoutRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for passwordLogin without sending the request
+     */
+    UsersServerApi.prototype.passwordLoginRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling passwordLogin().');
+                }
+                if (requestParameters['passwordLoginRequest'] == null) {
+                    throw new runtime.RequiredError('passwordLoginRequest', 'Required parameter "passwordLoginRequest" was null or undefined when calling passwordLogin().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/password-login";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, PasswordLoginRequest_1.PasswordLoginRequestToJSON)(requestParameters['passwordLoginRequest']),
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.passwordLoginRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.passwordLoginRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, LoginUserResponse_1.LoginUserResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.passwordLogin = 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.passwordLoginRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for previewMySubscriptionUpdate without sending the request
+     */
+    UsersServerApi.prototype.previewMySubscriptionUpdateRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling previewMySubscriptionUpdate().');
+                }
+                if (requestParameters['subscriptionId'] == null) {
+                    throw new runtime.RequiredError('subscriptionId', 'Required parameter "subscriptionId" was null or undefined when calling previewMySubscriptionUpdate().');
+                }
+                if (requestParameters['updateSubscriptionPreviewRequest'] == null) {
+                    throw new runtime.RequiredError('updateSubscriptionPreviewRequest', 'Required parameter "updateSubscriptionPreviewRequest" was null or undefined when calling previewMySubscriptionUpdate().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/subscriptions/{subscriptionId}/preview";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{subscriptionId}', encodeURIComponent(String(requestParameters['subscriptionId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, UpdateSubscriptionPreviewRequest_1.UpdateSubscriptionPreviewRequestToJSON)(requestParameters['updateSubscriptionPreviewRequest']),
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.previewMySubscriptionUpdateRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.previewMySubscriptionUpdateRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreateSubscriptionPreviewResponse_1.CreateSubscriptionPreviewResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.previewMySubscriptionUpdate = 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.previewMySubscriptionUpdateRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for registerUser without sending the request
+     */
+    UsersServerApi.prototype.registerUserRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling registerUser().');
+                }
+                if (requestParameters['registerUserRequest'] == null) {
+                    throw new runtime.RequiredError('registerUserRequest', 'Required parameter "registerUserRequest" was null or undefined when calling registerUser().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/register";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, RegisterUserRequest_1.RegisterUserRequestToJSON)(requestParameters['registerUserRequest']),
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.registerUserRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.registerUserRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, RegisterUserResponse_1.RegisterUserResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.registerUser = 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.registerUserRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for renameMfaMethod without sending the request
+     */
+    UsersServerApi.prototype.renameMfaMethodRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling renameMfaMethod().');
+                }
+                if (requestParameters['mfaMethodId'] == null) {
+                    throw new runtime.RequiredError('mfaMethodId', 'Required parameter "mfaMethodId" was null or undefined when calling renameMfaMethod().');
+                }
+                if (requestParameters['renameMfaMethodRequest'] == null) {
+                    throw new runtime.RequiredError('renameMfaMethodRequest', 'Required parameter "renameMfaMethodRequest" was null or undefined when calling renameMfaMethod().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/mfa/methods/{mfaMethodId}";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{mfaMethodId}', encodeURIComponent(String(requestParameters['mfaMethodId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'PUT',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, RenameMfaMethodRequest_1.RenameMfaMethodRequestToJSON)(requestParameters['renameMfaMethodRequest']),
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.renameMfaMethodRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.renameMfaMethodRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.renameMfaMethod = 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.renameMfaMethodRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for renewSessionToken without sending the request
+     */
+    UsersServerApi.prototype.renewSessionTokenRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling renewSessionToken().');
+                }
+                queryParameters = {};
+                if (requestParameters['renewalDurationSeconds'] != null) {
+                    queryParameters['renewalDurationSeconds'] = requestParameters['renewalDurationSeconds'];
+                }
+                headerParameters = {};
+                if (requestParameters['authorization'] != null) {
+                    headerParameters['Authorization'] = String(requestParameters['authorization']);
+                }
+                urlPath = "/api/v1/{projectId}/users/session-token/renew";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.renewSessionTokenRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.renewSessionTokenRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, RenewSessionTokenResponse_1.RenewSessionTokenResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.renewSessionToken = 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.renewSessionTokenRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for requestPasswordReset without sending the request
+     */
+    UsersServerApi.prototype.requestPasswordResetRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling requestPasswordReset().');
+                }
+                if (requestParameters['requestPasswordResetRequest'] == null) {
+                    throw new runtime.RequiredError('requestPasswordResetRequest', 'Required parameter "requestPasswordResetRequest" was null or undefined when calling requestPasswordReset().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/password-reset/request";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, RequestPasswordResetRequest_1.RequestPasswordResetRequestToJSON)(requestParameters['requestPasswordResetRequest']),
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.requestPasswordResetRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.requestPasswordResetRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.requestPasswordReset = 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.requestPasswordResetRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for resendContactMethodVerificationCode without sending the request
+     */
+    UsersServerApi.prototype.resendContactMethodVerificationCodeRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling resendContactMethodVerificationCode().');
+                }
+                if (requestParameters['contactMethodId'] == null) {
+                    throw new runtime.RequiredError('contactMethodId', 'Required parameter "contactMethodId" was null or undefined when calling resendContactMethodVerificationCode().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/api/v1/{projectId}/users/me/contact-methods/{contactMethodId}/resend-verification-code";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{contactMethodId}', encodeURIComponent(String(requestParameters['contactMethodId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.resendContactMethodVerificationCodeRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.resendContactMethodVerificationCodeRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ContactMethod_1.ContactMethodFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.resendContactMethodVerificationCode = 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.resendContactMethodVerificationCodeRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for resendLoginOtp without sending the request
+     */
+    UsersServerApi.prototype.resendLoginOtpRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling resendLoginOtp().');
+                }
+                if (requestParameters['pendingLoginId'] == null) {
+                    throw new runtime.RequiredError('pendingLoginId', 'Required parameter "pendingLoginId" was null or undefined when calling resendLoginOtp().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/api/v1/{projectId}/users/otp-login/{pendingLoginId}/resend";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{pendingLoginId}', encodeURIComponent(String(requestParameters['pendingLoginId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'POST',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.resendLoginOtpRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.resendLoginOtpRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreateOtpLoginResponse_1.CreateOtpLoginResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.resendLoginOtp = 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.resendLoginOtpRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for revokeUserInvite without sending the request
+     */
+    UsersServerApi.prototype.revokeUserInviteRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling revokeUserInvite().');
+                }
+                if (requestParameters['inviteId'] == null) {
+                    throw new runtime.RequiredError('inviteId', 'Required parameter "inviteId" was null or undefined when calling revokeUserInvite().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/api/v1/{projectId}/users/me/invites/{inviteId}";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{inviteId}', encodeURIComponent(String(requestParameters['inviteId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'DELETE',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.revokeUserInviteRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.revokeUserInviteRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.revokeUserInvite = 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.revokeUserInviteRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for sendMfaChallenge without sending the request
+     */
+    UsersServerApi.prototype.sendMfaChallengeRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling sendMfaChallenge().');
+                }
+                if (requestParameters['mfaChallengeRequest'] == null) {
+                    throw new runtime.RequiredError('mfaChallengeRequest', 'Required parameter "mfaChallengeRequest" was null or undefined when calling sendMfaChallenge().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/mfa/challenge";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
                 return [2 /*return*/, {
                         path: urlPath,
                         method: 'POST',
                         headers: headerParameters,
                         query: queryParameters,
+                        body: (0, MfaChallengeRequest_1.MfaChallengeRequestToJSON)(requestParameters['mfaChallengeRequest']),
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.sendMfaChallengeRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.sendMfaChallengeRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, MfaChallengeResponse_1.MfaChallengeResponseFromJSON)(jsonValue); })];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.sendMfaChallenge = 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.sendMfaChallengeRaw(requestParameters, initOverrides)];
+                    case 1:
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for updateMySubscription without sending the request
+     */
+    UsersServerApi.prototype.updateMySubscriptionRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling updateMySubscription().');
+                }
+                if (requestParameters['subscriptionId'] == null) {
+                    throw new runtime.RequiredError('subscriptionId', 'Required parameter "subscriptionId" was null or undefined when calling updateMySubscription().');
+                }
+                if (requestParameters['updateSubscriptionRequest'] == null) {
+                    throw new runtime.RequiredError('updateSubscriptionRequest', 'Required parameter "updateSubscriptionRequest" was null or undefined when calling updateMySubscription().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/subscriptions/{subscriptionId}";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{subscriptionId}', encodeURIComponent(String(requestParameters['subscriptionId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'PATCH',
+                        headers: headerParameters,
+                        query: queryParameters,
+                        body: (0, UpdateSubscriptionRequest_1.UpdateSubscriptionRequestToJSON)(requestParameters['updateSubscriptionRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.logoutRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.updateMySubscriptionRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.logoutRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.updateMySubscriptionRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, SubscriptionObject_1.SubscriptionObjectFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.logout = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.updateMySubscription = 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.logoutRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.updateMySubscriptionRaw(requestParameters, initOverrides)];
                     case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
     /**
-     * Creates request options for passwordLogin without sending the request
+     * Creates request options for usersCreateContentUploadLink without sending the request
      */
-    UsersServerApi.prototype.passwordLoginRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersCreateContentUploadLinkRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling passwordLogin().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersCreateContentUploadLink().');
                 }
-                if (requestParameters['passwordLoginRequest'] == null) {
-                    throw new runtime.RequiredError('passwordLoginRequest', 'Required parameter "passwordLoginRequest" was null or undefined when calling passwordLogin().');
+                if (requestParameters['createContentUploadLinkRequest'] == null) {
+                    throw new runtime.RequiredError('createContentUploadLinkRequest', 'Required parameter "createContentUploadLinkRequest" was null or undefined when calling usersCreateContentUploadLink().');
                 }
                 queryParameters = {};
                 headerParameters = {};
                 headerParameters['Content-Type'] = 'application/json';
-                urlPath = "/api/v1/{projectId}/users/password-login";
+                urlPath = "/api/v1/{projectId}/users/me/content/upload-links";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
                 return [2 /*return*/, {
                         path: urlPath,
                         method: 'POST',
                         headers: headerParameters,
                         query: queryParameters,
-                        body: (0, PasswordLoginRequest_1.PasswordLoginRequestToJSON)(requestParameters['passwordLoginRequest']),
+                        body: (0, CreateContentUploadLinkRequest_1.CreateContentUploadLinkRequestToJSON)(requestParameters['createContentUploadLinkRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.passwordLoginRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreateContentUploadLinkRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.passwordLoginRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersCreateContentUploadLinkRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, LoginUserResponse_1.LoginUserResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreateContentUploadLinkResponse_1.CreateContentUploadLinkResponseFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.passwordLogin = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreateContentUploadLink = 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.passwordLoginRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersCreateContentUploadLinkRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -926,59 +2173,59 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for registerUser without sending the request
+     * Creates request options for usersCreatePayment without sending the request
      */
-    UsersServerApi.prototype.registerUserRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersCreatePaymentRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling registerUser().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersCreatePayment().');
                 }
-                if (requestParameters['registerUserRequest'] == null) {
-                    throw new runtime.RequiredError('registerUserRequest', 'Required parameter "registerUserRequest" was null or undefined when calling registerUser().');
+                if (requestParameters['createPaymentRequest'] == null) {
+                    throw new runtime.RequiredError('createPaymentRequest', 'Required parameter "createPaymentRequest" was null or undefined when calling usersCreatePayment().');
                 }
                 queryParameters = {};
                 headerParameters = {};
                 headerParameters['Content-Type'] = 'application/json';
-                urlPath = "/api/v1/{projectId}/users/register";
+                urlPath = "/api/v1/{projectId}/users/me/payments";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
                 return [2 /*return*/, {
                         path: urlPath,
                         method: 'POST',
                         headers: headerParameters,
                         query: queryParameters,
-                        body: (0, RegisterUserRequest_1.RegisterUserRequestToJSON)(requestParameters['registerUserRequest']),
+                        body: (0, CreatePaymentRequest_1.CreatePaymentRequestToJSON)(requestParameters['createPaymentRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.registerUserRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreatePaymentRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.registerUserRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersCreatePaymentRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, RegisterUserResponse_1.RegisterUserResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreatePaymentResponse_1.CreatePaymentResponseFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.registerUser = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreatePayment = 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.registerUserRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersCreatePaymentRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -988,24 +2235,18 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for renewSessionToken without sending the request
+     * Creates request options for usersCreatePaymentMethod without sending the request
      */
-    UsersServerApi.prototype.renewSessionTokenRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersCreatePaymentMethodRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling renewSessionToken().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersCreatePaymentMethod().');
                 }
                 queryParameters = {};
-                if (requestParameters['renewalDurationSeconds'] != null) {
-                    queryParameters['renewalDurationSeconds'] = requestParameters['renewalDurationSeconds'];
-                }
                 headerParameters = {};
-                if (requestParameters['authorization'] != null) {
-                    headerParameters['Authorization'] = String(requestParameters['authorization']);
-                }
-                urlPath = "/api/v1/{projectId}/users/session-token/renew";
+                urlPath = "/api/v1/{projectId}/users/me/payment-methods";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
                 return [2 /*return*/, {
                         path: urlPath,
@@ -1018,30 +2259,30 @@ var UsersServerApi = /** @class */ (function (_super) {
     };
     /**
      */
-    UsersServerApi.prototype.renewSessionTokenRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreatePaymentMethodRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.renewSessionTokenRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersCreatePaymentMethodRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, RenewSessionTokenResponse_1.RenewSessionTokenResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreatePaymentMethodResponse_1.CreatePaymentMethodResponseFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.renewSessionToken = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreatePaymentMethod = 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.renewSessionTokenRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersCreatePaymentMethodRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -1051,118 +2292,121 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for requestPasswordReset without sending the request
+     * Creates request options for usersCreatePaymentPreview without sending the request
      */
-    UsersServerApi.prototype.requestPasswordResetRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersCreatePaymentPreviewRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling requestPasswordReset().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersCreatePaymentPreview().');
                 }
-                if (requestParameters['requestPasswordResetRequest'] == null) {
-                    throw new runtime.RequiredError('requestPasswordResetRequest', 'Required parameter "requestPasswordResetRequest" was null or undefined when calling requestPasswordReset().');
+                if (requestParameters['createPaymentPreviewRequest'] == null) {
+                    throw new runtime.RequiredError('createPaymentPreviewRequest', 'Required parameter "createPaymentPreviewRequest" was null or undefined when calling usersCreatePaymentPreview().');
                 }
                 queryParameters = {};
                 headerParameters = {};
                 headerParameters['Content-Type'] = 'application/json';
-                urlPath = "/api/v1/{projectId}/users/password-reset/request";
+                urlPath = "/api/v1/{projectId}/users/me/payments/preview";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
                 return [2 /*return*/, {
                         path: urlPath,
                         method: 'POST',
                         headers: headerParameters,
                         query: queryParameters,
-                        body: (0, RequestPasswordResetRequest_1.RequestPasswordResetRequestToJSON)(requestParameters['requestPasswordResetRequest']),
+                        body: (0, CreatePaymentPreviewRequest_1.CreatePaymentPreviewRequestToJSON)(requestParameters['createPaymentPreviewRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.requestPasswordResetRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreatePaymentPreviewRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.requestPasswordResetRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersCreatePaymentPreviewRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreatePaymentPreviewResponse_1.CreatePaymentPreviewResponseFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.requestPasswordReset = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreatePaymentPreview = 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.requestPasswordResetRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersCreatePaymentPreviewRaw(requestParameters, initOverrides)];
                     case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
     /**
-     * Creates request options for resendContactMethodVerificationCode without sending the request
+     * Creates request options for usersCreateSubscription without sending the request
      */
-    UsersServerApi.prototype.resendContactMethodVerificationCodeRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersCreateSubscriptionRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling resendContactMethodVerificationCode().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersCreateSubscription().');
                 }
-                if (requestParameters['contactMethodId'] == null) {
-                    throw new runtime.RequiredError('contactMethodId', 'Required parameter "contactMethodId" was null or undefined when calling resendContactMethodVerificationCode().');
+                if (requestParameters['createSubscriptionRequest'] == null) {
+                    throw new runtime.RequiredError('createSubscriptionRequest', 'Required parameter "createSubscriptionRequest" was null or undefined when calling usersCreateSubscription().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/me/contact-methods/{contactMethodId}/resend-verification-code";
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/subscriptions";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
-                urlPath = urlPath.replace('{contactMethodId}', encodeURIComponent(String(requestParameters['contactMethodId'])));
                 return [2 /*return*/, {
                         path: urlPath,
                         method: 'POST',
                         headers: headerParameters,
                         query: queryParameters,
+                        body: (0, CreateSubscriptionRequest_1.CreateSubscriptionRequestToJSON)(requestParameters['createSubscriptionRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.resendContactMethodVerificationCodeRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreateSubscriptionRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.resendContactMethodVerificationCodeRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersCreateSubscriptionRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ContactMethod_1.ContactMethodFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreateSubscriptionResponse_1.CreateSubscriptionResponseFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.resendContactMethodVerificationCode = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreateSubscription = 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.resendContactMethodVerificationCodeRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersCreateSubscriptionRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -1172,58 +2416,59 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for resendLoginOtp without sending the request
+     * Creates request options for usersCreateSubscriptionPreview without sending the request
      */
-    UsersServerApi.prototype.resendLoginOtpRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersCreateSubscriptionPreviewRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling resendLoginOtp().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersCreateSubscriptionPreview().');
                 }
-                if (requestParameters['pendingLoginId'] == null) {
-                    throw new runtime.RequiredError('pendingLoginId', 'Required parameter "pendingLoginId" was null or undefined when calling resendLoginOtp().');
+                if (requestParameters['createSubscriptionPreviewRequest'] == null) {
+                    throw new runtime.RequiredError('createSubscriptionPreviewRequest', 'Required parameter "createSubscriptionPreviewRequest" was null or undefined when calling usersCreateSubscriptionPreview().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/otp-login/{pendingLoginId}/resend";
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/subscriptions/preview";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
-                urlPath = urlPath.replace('{pendingLoginId}', encodeURIComponent(String(requestParameters['pendingLoginId'])));
                 return [2 /*return*/, {
                         path: urlPath,
                         method: 'POST',
                         headers: headerParameters,
                         query: queryParameters,
+                        body: (0, CreateSubscriptionPreviewRequest_1.CreateSubscriptionPreviewRequestToJSON)(requestParameters['createSubscriptionPreviewRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.resendLoginOtpRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreateSubscriptionPreviewRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.resendLoginOtpRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersCreateSubscriptionPreviewRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreateOtpLoginResponse_1.CreateOtpLoginResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreateSubscriptionPreviewResponse_1.CreateSubscriptionPreviewResponseFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.resendLoginOtp = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersCreateSubscriptionPreview = 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.resendLoginOtpRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersCreateSubscriptionPreviewRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -1233,26 +2478,144 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for revokeUserInvite without sending the request
+     * Creates request options for usersDeleteContent without sending the request
      */
-    UsersServerApi.prototype.revokeUserInviteRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersDeleteContentRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling revokeUserInvite().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersDeleteContent().');
                 }
-                if (requestParameters['inviteId'] == null) {
-                    throw new runtime.RequiredError('inviteId', 'Required parameter "inviteId" was null or undefined when calling revokeUserInvite().');
+                if (requestParameters['contentId'] == null) {
+                    throw new runtime.RequiredError('contentId', 'Required parameter "contentId" was null or undefined when calling usersDeleteContent().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/api/v1/{projectId}/users/me/content/{contentId}";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{contentId}', encodeURIComponent(String(requestParameters['contentId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'DELETE',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.usersDeleteContentRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.usersDeleteContentRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.usersDeleteContent = 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.usersDeleteContentRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for usersDeletePaymentMethod without sending the request
+     */
+    UsersServerApi.prototype.usersDeletePaymentMethodRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersDeletePaymentMethod().');
+                }
+                if (requestParameters['paymentMethodId'] == null) {
+                    throw new runtime.RequiredError('paymentMethodId', 'Required parameter "paymentMethodId" was null or undefined when calling usersDeletePaymentMethod().');
+                }
+                queryParameters = {};
+                headerParameters = {};
+                urlPath = "/api/v1/{projectId}/users/me/payment-methods/{paymentMethodId}";
+                urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{paymentMethodId}', encodeURIComponent(String(requestParameters['paymentMethodId'])));
+                return [2 /*return*/, {
+                        path: urlPath,
+                        method: 'DELETE',
+                        headers: headerParameters,
+                        query: queryParameters,
+                    }];
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.usersDeletePaymentMethodRaw = function (requestParameters, initOverrides) {
+        return __awaiter(this, void 0, void 0, function () {
+            var requestOptions, response;
+            return __generator(this, function (_a) {
+                switch (_a.label) {
+                    case 0: return [4 /*yield*/, this.usersDeletePaymentMethodRequestOpts(requestParameters)];
+                    case 1:
+                        requestOptions = _a.sent();
+                        return [4 /*yield*/, this.request(requestOptions, initOverrides)];
+                    case 2:
+                        response = _a.sent();
+                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                }
+            });
+        });
+    };
+    /**
+     */
+    UsersServerApi.prototype.usersDeletePaymentMethod = 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.usersDeletePaymentMethodRaw(requestParameters, initOverrides)];
+                    case 1:
+                        _a.sent();
+                        return [2 /*return*/];
+                }
+            });
+        });
+    };
+    /**
+     * Creates request options for usersFinalizeContent without sending the request
+     */
+    UsersServerApi.prototype.usersFinalizeContentRequestOpts = function (requestParameters) {
+        return __awaiter(this, void 0, void 0, function () {
+            var queryParameters, headerParameters, urlPath;
+            return __generator(this, function (_a) {
+                if (requestParameters['projectId'] == null) {
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersFinalizeContent().');
+                }
+                if (requestParameters['pendingContentId'] == null) {
+                    throw new runtime.RequiredError('pendingContentId', 'Required parameter "pendingContentId" was null or undefined when calling usersFinalizeContent().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/me/invites/{inviteId}";
+                urlPath = "/api/v1/{projectId}/users/me/content/{pendingContentId}";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
-                urlPath = urlPath.replace('{inviteId}', encodeURIComponent(String(requestParameters['inviteId'])));
+                urlPath = urlPath.replace('{pendingContentId}', encodeURIComponent(String(requestParameters['pendingContentId'])));
                 return [2 /*return*/, {
                         path: urlPath,
-                        method: 'DELETE',
+                        method: 'POST',
                         headers: headerParameters,
                         query: queryParameters,
                     }];
@@ -1261,90 +2624,91 @@ var UsersServerApi = /** @class */ (function (_super) {
     };
     /**
      */
-    UsersServerApi.prototype.revokeUserInviteRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersFinalizeContentRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.revokeUserInviteRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersFinalizeContentRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ContentObject_1.ContentObjectFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.revokeUserInvite = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersFinalizeContent = 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.revokeUserInviteRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersFinalizeContentRaw(requestParameters, initOverrides)];
                     case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
     /**
-     * Creates request options for usersCreateContentUploadLink without sending the request
+     * Creates request options for usersGetContent without sending the request
      */
-    UsersServerApi.prototype.usersCreateContentUploadLinkRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersGetContentRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersCreateContentUploadLink().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersGetContent().');
                 }
-                if (requestParameters['createContentUploadLinkRequest'] == null) {
-                    throw new runtime.RequiredError('createContentUploadLinkRequest', 'Required parameter "createContentUploadLinkRequest" was null or undefined when calling usersCreateContentUploadLink().');
+                if (requestParameters['contentId'] == null) {
+                    throw new runtime.RequiredError('contentId', 'Required parameter "contentId" was null or undefined when calling usersGetContent().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                headerParameters['Content-Type'] = 'application/json';
-                urlPath = "/api/v1/{projectId}/users/me/content/upload-links";
+                urlPath = "/api/v1/{projectId}/users/me/content/{contentId}";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{contentId}', encodeURIComponent(String(requestParameters['contentId'])));
                 return [2 /*return*/, {
                         path: urlPath,
-                        method: 'POST',
+                        method: 'GET',
                         headers: headerParameters,
                         query: queryParameters,
-                        body: (0, CreateContentUploadLinkRequest_1.CreateContentUploadLinkRequestToJSON)(requestParameters['createContentUploadLinkRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersCreateContentUploadLinkRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersGetContentRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.usersCreateContentUploadLinkRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersGetContentRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreateContentUploadLinkResponse_1.CreateContentUploadLinkResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ContentObject_1.ContentObjectFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersCreateContentUploadLink = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersGetContent = 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.usersCreateContentUploadLinkRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersGetContentRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -1354,59 +2718,58 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for usersCreatePayment without sending the request
+     * Creates request options for usersGetContentDownloadLink without sending the request
      */
-    UsersServerApi.prototype.usersCreatePaymentRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersGetContentDownloadLinkRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersCreatePayment().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersGetContentDownloadLink().');
                 }
-                if (requestParameters['createPaymentRequest'] == null) {
-                    throw new runtime.RequiredError('createPaymentRequest', 'Required parameter "createPaymentRequest" was null or undefined when calling usersCreatePayment().');
+                if (requestParameters['contentId'] == null) {
+                    throw new runtime.RequiredError('contentId', 'Required parameter "contentId" was null or undefined when calling usersGetContentDownloadLink().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                headerParameters['Content-Type'] = 'application/json';
-                urlPath = "/api/v1/{projectId}/users/me/payments";
+                urlPath = "/api/v1/{projectId}/users/me/content/{contentId}/download-link";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{contentId}', encodeURIComponent(String(requestParameters['contentId'])));
                 return [2 /*return*/, {
                         path: urlPath,
-                        method: 'POST',
+                        method: 'GET',
                         headers: headerParameters,
                         query: queryParameters,
-                        body: (0, CreatePaymentRequest_1.CreatePaymentRequestToJSON)(requestParameters['createPaymentRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersCreatePaymentRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersGetContentDownloadLinkRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.usersCreatePaymentRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersGetContentDownloadLinkRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreatePaymentResponse_1.CreatePaymentResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, GetContentDownloadLinkResponse_1.GetContentDownloadLinkResponseFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersCreatePayment = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersGetContentDownloadLink = 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.usersCreatePaymentRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersGetContentDownloadLinkRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -1416,59 +2779,58 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for usersCreatePaymentPreview without sending the request
+     * Creates request options for usersGetPaymentMethod without sending the request
      */
-    UsersServerApi.prototype.usersCreatePaymentPreviewRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersGetPaymentMethodRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersCreatePaymentPreview().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersGetPaymentMethod().');
                 }
-                if (requestParameters['createPaymentPreviewRequest'] == null) {
-                    throw new runtime.RequiredError('createPaymentPreviewRequest', 'Required parameter "createPaymentPreviewRequest" was null or undefined when calling usersCreatePaymentPreview().');
+                if (requestParameters['paymentMethodId'] == null) {
+                    throw new runtime.RequiredError('paymentMethodId', 'Required parameter "paymentMethodId" was null or undefined when calling usersGetPaymentMethod().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                headerParameters['Content-Type'] = 'application/json';
-                urlPath = "/api/v1/{projectId}/users/me/payments/preview";
+                urlPath = "/api/v1/{projectId}/users/me/payment-methods/{paymentMethodId}";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{paymentMethodId}', encodeURIComponent(String(requestParameters['paymentMethodId'])));
                 return [2 /*return*/, {
                         path: urlPath,
-                        method: 'POST',
+                        method: 'GET',
                         headers: headerParameters,
                         query: queryParameters,
-                        body: (0, CreatePaymentPreviewRequest_1.CreatePaymentPreviewRequestToJSON)(requestParameters['createPaymentPreviewRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersCreatePaymentPreviewRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersGetPaymentMethodRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.usersCreatePaymentPreviewRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersGetPaymentMethodRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, CreatePaymentPreviewResponse_1.CreatePaymentPreviewResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, PaymentMethodObject_1.PaymentMethodObjectFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersCreatePaymentPreview = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersGetPaymentMethod = 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.usersCreatePaymentPreviewRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersGetPaymentMethodRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -1478,26 +2840,28 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for usersDeleteContent without sending the request
+     * Creates request options for usersListContent without sending the request
      */
-    UsersServerApi.prototype.usersDeleteContentRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersListContentRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersDeleteContent().');
-                }
-                if (requestParameters['contentId'] == null) {
-                    throw new runtime.RequiredError('contentId', 'Required parameter "contentId" was null or undefined when calling usersDeleteContent().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersListContent().');
                 }
                 queryParameters = {};
+                if (requestParameters['page'] != null) {
+                    queryParameters['page'] = requestParameters['page'];
+                }
+                if (requestParameters['pageSize'] != null) {
+                    queryParameters['pageSize'] = requestParameters['pageSize'];
+                }
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/me/content/{contentId}";
+                urlPath = "/api/v1/{projectId}/users/me/content";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
-                urlPath = urlPath.replace('{contentId}', encodeURIComponent(String(requestParameters['contentId'])));
                 return [2 /*return*/, {
                         path: urlPath,
-                        method: 'DELETE',
+                        method: 'GET',
                         headers: headerParameters,
                         query: queryParameters,
                     }];
@@ -1506,57 +2870,55 @@ var UsersServerApi = /** @class */ (function (_super) {
     };
     /**
      */
-    UsersServerApi.prototype.usersDeleteContentRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersListContentRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.usersDeleteContentRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersListContentRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.VoidApiResponse(response)];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ListContentResponse_1.ListContentResponseFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersDeleteContent = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersListContent = 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.usersDeleteContentRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersListContentRaw(requestParameters, initOverrides)];
                     case 1:
-                        _a.sent();
-                        return [2 /*return*/];
+                        response = _a.sent();
+                        return [4 /*yield*/, response.value()];
+                    case 2: return [2 /*return*/, _a.sent()];
                 }
             });
         });
     };
     /**
-     * Creates request options for usersFinalizeContent without sending the request
+     * Creates request options for usersListPaymentMethods without sending the request
      */
-    UsersServerApi.prototype.usersFinalizeContentRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersListPaymentMethodsRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersFinalizeContent().');
-                }
-                if (requestParameters['pendingContentId'] == null) {
-                    throw new runtime.RequiredError('pendingContentId', 'Required parameter "pendingContentId" was null or undefined when calling usersFinalizeContent().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersListPaymentMethods().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/me/content/{pendingContentId}";
+                urlPath = "/api/v1/{projectId}/users/me/payment-methods";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
-                urlPath = urlPath.replace('{pendingContentId}', encodeURIComponent(String(requestParameters['pendingContentId'])));
                 return [2 /*return*/, {
                         path: urlPath,
-                        method: 'POST',
+                        method: 'GET',
                         headers: headerParameters,
                         query: queryParameters,
                     }];
@@ -1565,30 +2927,30 @@ var UsersServerApi = /** @class */ (function (_super) {
     };
     /**
      */
-    UsersServerApi.prototype.usersFinalizeContentRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersListPaymentMethodsRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.usersFinalizeContentRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersListPaymentMethodsRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ContentObject_1.ContentObjectFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return jsonValue.map(PaymentMethodObject_1.PaymentMethodObjectFromJSON); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersFinalizeContent = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersListPaymentMethods = 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.usersFinalizeContentRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersListPaymentMethodsRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -1598,40 +2960,45 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for usersGetContent without sending the request
+     * Creates request options for usersUpdateContentOwner without sending the request
      */
-    UsersServerApi.prototype.usersGetContentRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersUpdateContentOwnerRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersGetContent().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersUpdateContentOwner().');
                 }
                 if (requestParameters['contentId'] == null) {
-                    throw new runtime.RequiredError('contentId', 'Required parameter "contentId" was null or undefined when calling usersGetContent().');
+                    throw new runtime.RequiredError('contentId', 'Required parameter "contentId" was null or undefined when calling usersUpdateContentOwner().');
+                }
+                if (requestParameters['updateContentOwnerRequest'] == null) {
+                    throw new runtime.RequiredError('updateContentOwnerRequest', 'Required parameter "updateContentOwnerRequest" was null or undefined when calling usersUpdateContentOwner().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/me/content/{contentId}";
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/content/{contentId}/owner";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
                 urlPath = urlPath.replace('{contentId}', encodeURIComponent(String(requestParameters['contentId'])));
                 return [2 /*return*/, {
                         path: urlPath,
-                        method: 'GET',
+                        method: 'PUT',
                         headers: headerParameters,
                         query: queryParameters,
+                        body: (0, UpdateContentOwnerRequest_1.UpdateContentOwnerRequestToJSON)(requestParameters['updateContentOwnerRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersGetContentRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersUpdateContentOwnerRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.usersGetContentRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersUpdateContentOwnerRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
@@ -1644,12 +3011,12 @@ var UsersServerApi = /** @class */ (function (_super) {
     };
     /**
      */
-    UsersServerApi.prototype.usersGetContent = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersUpdateContentOwner = 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.usersGetContentRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersUpdateContentOwnerRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -1659,58 +3026,63 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for usersGetContentDownloadLink without sending the request
+     * Creates request options for usersUpdateContentShares without sending the request
      */
-    UsersServerApi.prototype.usersGetContentDownloadLinkRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersUpdateContentSharesRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersGetContentDownloadLink().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersUpdateContentShares().');
                 }
                 if (requestParameters['contentId'] == null) {
-                    throw new runtime.RequiredError('contentId', 'Required parameter "contentId" was null or undefined when calling usersGetContentDownloadLink().');
+                    throw new runtime.RequiredError('contentId', 'Required parameter "contentId" was null or undefined when calling usersUpdateContentShares().');
+                }
+                if (requestParameters['updateContentSharesRequest'] == null) {
+                    throw new runtime.RequiredError('updateContentSharesRequest', 'Required parameter "updateContentSharesRequest" was null or undefined when calling usersUpdateContentShares().');
                 }
                 queryParameters = {};
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/me/content/{contentId}/download-link";
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/content/{contentId}/shares";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
                 urlPath = urlPath.replace('{contentId}', encodeURIComponent(String(requestParameters['contentId'])));
                 return [2 /*return*/, {
                         path: urlPath,
-                        method: 'GET',
+                        method: 'PUT',
                         headers: headerParameters,
                         query: queryParameters,
+                        body: (0, UpdateContentSharesRequest_1.UpdateContentSharesRequestToJSON)(requestParameters['updateContentSharesRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersGetContentDownloadLinkRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersUpdateContentSharesRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.usersGetContentDownloadLinkRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersUpdateContentSharesRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, GetContentDownloadLinkResponse_1.GetContentDownloadLinkResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ContentObject_1.ContentObjectFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersGetContentDownloadLink = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersUpdateContentShares = 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.usersGetContentDownloadLinkRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersUpdateContentSharesRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -1720,60 +3092,63 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for usersListContent without sending the request
+     * Creates request options for usersUpdatePaymentMethod without sending the request
      */
-    UsersServerApi.prototype.usersListContentRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.usersUpdatePaymentMethodRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersListContent().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersUpdatePaymentMethod().');
                 }
-                queryParameters = {};
-                if (requestParameters['page'] != null) {
-                    queryParameters['page'] = requestParameters['page'];
+                if (requestParameters['paymentMethodId'] == null) {
+                    throw new runtime.RequiredError('paymentMethodId', 'Required parameter "paymentMethodId" was null or undefined when calling usersUpdatePaymentMethod().');
                 }
-                if (requestParameters['pageSize'] != null) {
-                    queryParameters['pageSize'] = requestParameters['pageSize'];
+                if (requestParameters['updatePaymentMethodRequest'] == null) {
+                    throw new runtime.RequiredError('updatePaymentMethodRequest', 'Required parameter "updatePaymentMethodRequest" was null or undefined when calling usersUpdatePaymentMethod().');
                 }
+                queryParameters = {};
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/me/content";
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/payment-methods/{paymentMethodId}";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
+                urlPath = urlPath.replace('{paymentMethodId}', encodeURIComponent(String(requestParameters['paymentMethodId'])));
                 return [2 /*return*/, {
                         path: urlPath,
-                        method: 'GET',
+                        method: 'PATCH',
                         headers: headerParameters,
                         query: queryParameters,
+                        body: (0, UpdatePaymentMethodRequest_1.UpdatePaymentMethodRequestToJSON)(requestParameters['updatePaymentMethodRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersListContentRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersUpdatePaymentMethodRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.usersListContentRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.usersUpdatePaymentMethodRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ListContentResponse_1.ListContentResponseFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, PaymentMethodObject_1.PaymentMethodObjectFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersListContent = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.usersUpdatePaymentMethod = 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.usersListContentRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.usersUpdatePaymentMethodRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -1783,63 +3158,64 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for usersUpdateContentShares without sending the request
+     * Creates request options for verifyContactMethod without sending the request
      */
-    UsersServerApi.prototype.usersUpdateContentSharesRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.verifyContactMethodRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling usersUpdateContentShares().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling verifyContactMethod().');
                 }
-                if (requestParameters['contentId'] == null) {
-                    throw new runtime.RequiredError('contentId', 'Required parameter "contentId" was null or undefined when calling usersUpdateContentShares().');
+                if (requestParameters['contactMethodId'] == null) {
+                    throw new runtime.RequiredError('contactMethodId', 'Required parameter "contactMethodId" was null or undefined when calling verifyContactMethod().');
                 }
-                if (requestParameters['updateContentSharesRequest'] == null) {
-                    throw new runtime.RequiredError('updateContentSharesRequest', 'Required parameter "updateContentSharesRequest" was null or undefined when calling usersUpdateContentShares().');
+                if (requestParameters['verificationCode'] == null) {
+                    throw new runtime.RequiredError('verificationCode', 'Required parameter "verificationCode" was null or undefined when calling verifyContactMethod().');
                 }
                 queryParameters = {};
+                if (requestParameters['verificationCode'] != null) {
+                    queryParameters['verificationCode'] = requestParameters['verificationCode'];
+                }
                 headerParameters = {};
-                headerParameters['Content-Type'] = 'application/json';
-                urlPath = "/api/v1/{projectId}/users/me/content/{contentId}/shares";
+                urlPath = "/api/v1/{projectId}/users/me/contact-methods/{contactMethodId}/verification";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
-                urlPath = urlPath.replace('{contentId}', encodeURIComponent(String(requestParameters['contentId'])));
+                urlPath = urlPath.replace('{contactMethodId}', encodeURIComponent(String(requestParameters['contactMethodId'])));
                 return [2 /*return*/, {
                         path: urlPath,
-                        method: 'PUT',
+                        method: 'POST',
                         headers: headerParameters,
                         query: queryParameters,
-                        body: (0, UpdateContentSharesRequest_1.UpdateContentSharesRequestToJSON)(requestParameters['updateContentSharesRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersUpdateContentSharesRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.verifyContactMethodRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.usersUpdateContentSharesRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.verifyContactMethodRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ContentObject_1.ContentObjectFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ContactMethod_1.ContactMethodFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.usersUpdateContentShares = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.verifyContactMethod = 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.usersUpdateContentSharesRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.verifyContactMethodRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];
@@ -1849,64 +3225,59 @@ var UsersServerApi = /** @class */ (function (_super) {
         });
     };
     /**
-     * Creates request options for verifyContactMethod without sending the request
+     * Creates request options for verifyMfa without sending the request
      */
-    UsersServerApi.prototype.verifyContactMethodRequestOpts = function (requestParameters) {
+    UsersServerApi.prototype.verifyMfaRequestOpts = function (requestParameters) {
         return __awaiter(this, void 0, void 0, function () {
             var queryParameters, headerParameters, urlPath;
             return __generator(this, function (_a) {
                 if (requestParameters['projectId'] == null) {
-                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling verifyContactMethod().');
-                }
-                if (requestParameters['contactMethodId'] == null) {
-                    throw new runtime.RequiredError('contactMethodId', 'Required parameter "contactMethodId" was null or undefined when calling verifyContactMethod().');
+                    throw new runtime.RequiredError('projectId', 'Required parameter "projectId" was null or undefined when calling verifyMfa().');
                 }
-                if (requestParameters['verificationCode'] == null) {
-                    throw new runtime.RequiredError('verificationCode', 'Required parameter "verificationCode" was null or undefined when calling verifyContactMethod().');
+                if (requestParameters['mfaVerifyRequest'] == null) {
+                    throw new runtime.RequiredError('mfaVerifyRequest', 'Required parameter "mfaVerifyRequest" was null or undefined when calling verifyMfa().');
                 }
                 queryParameters = {};
-                if (requestParameters['verificationCode'] != null) {
-                    queryParameters['verificationCode'] = requestParameters['verificationCode'];
-                }
                 headerParameters = {};
-                urlPath = "/api/v1/{projectId}/users/me/contact-methods/{contactMethodId}/verification";
+                headerParameters['Content-Type'] = 'application/json';
+                urlPath = "/api/v1/{projectId}/users/me/mfa/verify";
                 urlPath = urlPath.replace('{projectId}', encodeURIComponent(String(requestParameters['projectId'])));
-                urlPath = urlPath.replace('{contactMethodId}', encodeURIComponent(String(requestParameters['contactMethodId'])));
                 return [2 /*return*/, {
                         path: urlPath,
                         method: 'POST',
                         headers: headerParameters,
                         query: queryParameters,
+                        body: (0, MfaVerifyRequest_1.MfaVerifyRequestToJSON)(requestParameters['mfaVerifyRequest']),
                     }];
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.verifyContactMethodRaw = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.verifyMfaRaw = function (requestParameters, initOverrides) {
         return __awaiter(this, void 0, void 0, function () {
             var requestOptions, response;
             return __generator(this, function (_a) {
                 switch (_a.label) {
-                    case 0: return [4 /*yield*/, this.verifyContactMethodRequestOpts(requestParameters)];
+                    case 0: return [4 /*yield*/, this.verifyMfaRequestOpts(requestParameters)];
                     case 1:
                         requestOptions = _a.sent();
                         return [4 /*yield*/, this.request(requestOptions, initOverrides)];
                     case 2:
                         response = _a.sent();
-                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, ContactMethod_1.ContactMethodFromJSON)(jsonValue); })];
+                        return [2 /*return*/, new runtime.JSONApiResponse(response, function (jsonValue) { return (0, LoginUserResponse_1.LoginUserResponseFromJSON)(jsonValue); })];
                 }
             });
         });
     };
     /**
      */
-    UsersServerApi.prototype.verifyContactMethod = function (requestParameters, initOverrides) {
+    UsersServerApi.prototype.verifyMfa = 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.verifyContactMethodRaw(requestParameters, initOverrides)];
+                    case 0: return [4 /*yield*/, this.verifyMfaRaw(requestParameters, initOverrides)];
                     case 1:
                         response = _a.sent();
                         return [4 /*yield*/, response.value()];