fastcomments-sdk 2.1.2 → 3.1.0

package/dist/generated/src/apis/DefaultApi.js

@@ -46,7 +46,7 @@ var __importStar = (this && this.__importStar) || (function () {
     };
 })();
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DefaultApi = void 0;
+exports.CreateVoteDirectionEnum = exports.DefaultApi = void 0;
 const runtime = __importStar(require("../runtime"));
 const index_1 = require("../models/index");
 /**
@@ -86,6 +86,60 @@ class DefaultApi extends runtime.BaseAPI {
         const response = await this.addDomainConfigRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     */
+    async addHashTagRaw(requestParameters, initOverrides) {
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/hash-tags`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.CreateHashTagBodyToJSON)(requestParameters['createHashTagBody']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.AddHashTag200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async addHashTag(requestParameters = {}, initOverrides) {
+        const response = await this.addHashTagRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async addHashTagsBulkRaw(requestParameters, initOverrides) {
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/hash-tags/bulk`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.BulkCreateHashTagsBodyToJSON)(requestParameters['bulkCreateHashTagsBody']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.AddHashTagsBulk200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async addHashTagsBulk(requestParameters = {}, initOverrides) {
+        const response = await this.addHashTagsBulkRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      */
     async addPageRaw(requestParameters, initOverrides) {
@@ -369,6 +423,39 @@ class DefaultApi extends runtime.BaseAPI {
         const response = await this.combineCommentsWithQuestionResultsRaw(requestParameters, initOverrides);
         return await response.value();
     }
+    /**
+     */
+    async createEmailTemplateRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createEmailTemplate().');
+        }
+        if (requestParameters['createEmailTemplateBody'] == null) {
+            throw new runtime.RequiredError('createEmailTemplateBody', 'Required parameter "createEmailTemplateBody" was null or undefined when calling createEmailTemplate().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/email-templates`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.CreateEmailTemplateBodyToJSON)(requestParameters['createEmailTemplateBody']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateEmailTemplate200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async createEmailTemplate(requestParameters, initOverrides) {
+        const response = await this.createEmailTemplateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
     /**
      */
     async createFeedPostRaw(requestParameters, initOverrides) {
@@ -416,12 +503,12 @@ class DefaultApi extends runtime.BaseAPI {
     }
     /**
      */
-    async createSubscriptionRaw(requestParameters, initOverrides) {
+    async createModeratorRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createSubscription().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createModerator().');
         }
-        if (requestParameters['createAPIUserSubscriptionData'] == null) {
-            throw new runtime.RequiredError('createAPIUserSubscriptionData', 'Required parameter "createAPIUserSubscriptionData" was null or undefined when calling createSubscription().');
+        if (requestParameters['createModeratorBody'] == null) {
+            throw new runtime.RequiredError('createModeratorBody', 'Required parameter "createModeratorBody" was null or undefined when calling createModerator().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
@@ -433,28 +520,28 @@ class DefaultApi extends runtime.BaseAPI {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/subscriptions`,
+            path: `/api/v1/moderators`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.CreateAPIUserSubscriptionDataToJSON)(requestParameters['createAPIUserSubscriptionData']),
+            body: (0, index_1.CreateModeratorBodyToJSON)(requestParameters['createModeratorBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateSubscriptionAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateModerator200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async createSubscription(requestParameters, initOverrides) {
-        const response = await this.createSubscriptionRaw(requestParameters, initOverrides);
+    async createModerator(requestParameters, initOverrides) {
+        const response = await this.createModeratorRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async createUserBadgeRaw(requestParameters, initOverrides) {
+    async createQuestionConfigRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createUserBadge().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createQuestionConfig().');
         }
-        if (requestParameters['createUserBadgeParams'] == null) {
-            throw new runtime.RequiredError('createUserBadgeParams', 'Required parameter "createUserBadgeParams" was null or undefined when calling createUserBadge().');
+        if (requestParameters['createQuestionConfigBody'] == null) {
+            throw new runtime.RequiredError('createQuestionConfigBody', 'Required parameter "createQuestionConfigBody" was null or undefined when calling createQuestionConfig().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
@@ -466,234 +553,240 @@ class DefaultApi extends runtime.BaseAPI {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/user-badges`,
+            path: `/api/v1/question-configs`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.CreateUserBadgeParamsToJSON)(requestParameters['createUserBadgeParams']),
+            body: (0, index_1.CreateQuestionConfigBodyToJSON)(requestParameters['createQuestionConfigBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateUserBadge200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateQuestionConfig200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async createUserBadge(requestParameters, initOverrides) {
-        const response = await this.createUserBadgeRaw(requestParameters, initOverrides);
+    async createQuestionConfig(requestParameters, initOverrides) {
+        const response = await this.createQuestionConfigRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async deleteCommentRaw(requestParameters, initOverrides) {
+    async createQuestionResultRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteComment().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createQuestionResult().');
         }
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteComment().');
+        if (requestParameters['createQuestionResultBody'] == null) {
+            throw new runtime.RequiredError('createQuestionResultBody', 'Required parameter "createQuestionResultBody" was null or undefined when calling createQuestionResult().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['contextUserId'] != null) {
-            queryParameters['contextUserId'] = requestParameters['contextUserId'];
-        }
-        if (requestParameters['isLive'] != null) {
-            queryParameters['isLive'] = requestParameters['isLive'];
-        }
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/comments/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'DELETE',
+            path: `/api/v1/question-results`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.CreateQuestionResultBodyToJSON)(requestParameters['createQuestionResultBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeleteComment200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateQuestionResult200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async deleteComment(requestParameters, initOverrides) {
-        const response = await this.deleteCommentRaw(requestParameters, initOverrides);
+    async createQuestionResult(requestParameters, initOverrides) {
+        const response = await this.createQuestionResultRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async deleteDomainConfigRaw(requestParameters, initOverrides) {
+    async createSubscriptionRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteDomainConfig().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createSubscription().');
         }
-        if (requestParameters['domain'] == null) {
-            throw new runtime.RequiredError('domain', 'Required parameter "domain" was null or undefined when calling deleteDomainConfig().');
+        if (requestParameters['createAPIUserSubscriptionData'] == null) {
+            throw new runtime.RequiredError('createAPIUserSubscriptionData', 'Required parameter "createAPIUserSubscriptionData" was null or undefined when calling createSubscription().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/domain-configs/{domain}`.replace(`{${"domain"}}`, encodeURIComponent(String(requestParameters['domain']))),
-            method: 'DELETE',
+            path: `/api/v1/subscriptions`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.CreateAPIUserSubscriptionDataToJSON)(requestParameters['createAPIUserSubscriptionData']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeleteDomainConfig200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateSubscriptionAPIResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async deleteDomainConfig(requestParameters, initOverrides) {
-        const response = await this.deleteDomainConfigRaw(requestParameters, initOverrides);
+    async createSubscription(requestParameters, initOverrides) {
+        const response = await this.createSubscriptionRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async deletePageRaw(requestParameters, initOverrides) {
+    async createTenantRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deletePage().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createTenant().');
         }
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deletePage().');
+        if (requestParameters['createTenantBody'] == null) {
+            throw new runtime.RequiredError('createTenantBody', 'Required parameter "createTenantBody" was null or undefined when calling createTenant().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/pages/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'DELETE',
+            path: `/api/v1/tenants`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.CreateTenantBodyToJSON)(requestParameters['createTenantBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeletePageAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateTenant200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async deletePage(requestParameters, initOverrides) {
-        const response = await this.deletePageRaw(requestParameters, initOverrides);
+    async createTenant(requestParameters, initOverrides) {
+        const response = await this.createTenantRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async deleteSSOUserRaw(requestParameters, initOverrides) {
+    async createTenantPackageRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteSSOUser().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createTenantPackage().');
         }
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteSSOUser().');
+        if (requestParameters['createTenantPackageBody'] == null) {
+            throw new runtime.RequiredError('createTenantPackageBody', 'Required parameter "createTenantPackageBody" was null or undefined when calling createTenantPackage().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['deleteComments'] != null) {
-            queryParameters['deleteComments'] = requestParameters['deleteComments'];
-        }
-        if (requestParameters['commentDeleteMode'] != null) {
-            queryParameters['commentDeleteMode'] = requestParameters['commentDeleteMode'];
-        }
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/sso-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'DELETE',
+            path: `/api/v1/tenant-packages`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.CreateTenantPackageBodyToJSON)(requestParameters['createTenantPackageBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeleteSSOUserAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateTenantPackage200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async deleteSSOUser(requestParameters, initOverrides) {
-        const response = await this.deleteSSOUserRaw(requestParameters, initOverrides);
+    async createTenantPackage(requestParameters, initOverrides) {
+        const response = await this.createTenantPackageRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async deleteSubscriptionRaw(requestParameters, initOverrides) {
+    async createTenantUserRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteSubscription().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createTenantUser().');
         }
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteSubscription().');
+        if (requestParameters['createTenantUserBody'] == null) {
+            throw new runtime.RequiredError('createTenantUserBody', 'Required parameter "createTenantUserBody" was null or undefined when calling createTenantUser().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['userId'] != null) {
-            queryParameters['userId'] = requestParameters['userId'];
-        }
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'DELETE',
+            path: `/api/v1/tenant-users`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.CreateTenantUserBodyToJSON)(requestParameters['createTenantUserBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeleteSubscriptionAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateTenantUser200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async deleteSubscription(requestParameters, initOverrides) {
-        const response = await this.deleteSubscriptionRaw(requestParameters, initOverrides);
+    async createTenantUser(requestParameters, initOverrides) {
+        const response = await this.createTenantUserRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async deleteUserBadgeRaw(requestParameters, initOverrides) {
+    async createUserBadgeRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteUserBadge().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createUserBadge().');
         }
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteUserBadge().');
+        if (requestParameters['createUserBadgeParams'] == null) {
+            throw new runtime.RequiredError('createUserBadgeParams', 'Required parameter "createUserBadgeParams" was null or undefined when calling createUserBadge().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/user-badges/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'DELETE',
+            path: `/api/v1/user-badges`,
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.CreateUserBadgeParamsToJSON)(requestParameters['createUserBadgeParams']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.UpdateUserBadge200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateUserBadge200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async deleteUserBadge(requestParameters, initOverrides) {
-        const response = await this.deleteUserBadgeRaw(requestParameters, initOverrides);
+    async createUserBadge(requestParameters, initOverrides) {
+        const response = await this.createUserBadgeRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async flagCommentRaw(requestParameters, initOverrides) {
+    async createVoteRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling flagComment().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling createVote().');
         }
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling flagComment().');
+        if (requestParameters['commentId'] == null) {
+            throw new runtime.RequiredError('commentId', 'Required parameter "commentId" was null or undefined when calling createVote().');
+        }
+        if (requestParameters['direction'] == null) {
+            throw new runtime.RequiredError('direction', 'Required parameter "direction" was null or undefined when calling createVote().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
+        if (requestParameters['commentId'] != null) {
+            queryParameters['commentId'] = requestParameters['commentId'];
+        }
+        if (requestParameters['direction'] != null) {
+            queryParameters['direction'] = requestParameters['direction'];
+        }
         if (requestParameters['userId'] != null) {
             queryParameters['userId'] = requestParameters['userId'];
         }
@@ -705,70 +798,64 @@ class DefaultApi extends runtime.BaseAPI {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/comments/{id}/flag`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            path: `/api/v1/votes`,
             method: 'POST',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagComment200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.CreateVote200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async flagComment(requestParameters, initOverrides) {
-        const response = await this.flagCommentRaw(requestParameters, initOverrides);
+    async createVote(requestParameters, initOverrides) {
+        const response = await this.createVoteRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getAuditLogsRaw(requestParameters, initOverrides) {
+    async deleteCommentRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getAuditLogs().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteComment().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteComment().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
-        }
-        if (requestParameters['skip'] != null) {
-            queryParameters['skip'] = requestParameters['skip'];
-        }
-        if (requestParameters['order'] != null) {
-            queryParameters['order'] = requestParameters['order'];
-        }
-        if (requestParameters['after'] != null) {
-            queryParameters['after'] = requestParameters['after'];
+        if (requestParameters['contextUserId'] != null) {
+            queryParameters['contextUserId'] = requestParameters['contextUserId'];
         }
-        if (requestParameters['before'] != null) {
-            queryParameters['before'] = requestParameters['before'];
+        if (requestParameters['isLive'] != null) {
+            queryParameters['isLive'] = requestParameters['isLive'];
         }
         const headerParameters = {};
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/audit-logs`,
-            method: 'GET',
+            path: `/api/v1/comments/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetAuditLogs200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeleteComment200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getAuditLogs(requestParameters, initOverrides) {
-        const response = await this.getAuditLogsRaw(requestParameters, initOverrides);
+    async deleteComment(requestParameters, initOverrides) {
+        const response = await this.deleteCommentRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getCommentRaw(requestParameters, initOverrides) {
+    async deleteDomainConfigRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getComment().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteDomainConfig().');
         }
-        if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getComment().');
+        if (requestParameters['domain'] == null) {
+            throw new runtime.RequiredError('domain', 'Required parameter "domain" was null or undefined when calling deleteDomainConfig().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
@@ -779,97 +866,61 @@ class DefaultApi extends runtime.BaseAPI {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/comments/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'GET',
+            path: `/api/v1/domain-configs/{domain}`.replace(`{${"domain"}}`, encodeURIComponent(String(requestParameters['domain']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetComment200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeleteDomainConfig200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getComment(requestParameters, initOverrides) {
-        const response = await this.getCommentRaw(requestParameters, initOverrides);
+    async deleteDomainConfig(requestParameters, initOverrides) {
+        const response = await this.deleteDomainConfigRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getCommentsRaw(requestParameters, initOverrides) {
+    async deleteEmailTemplateRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getComments().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteEmailTemplate().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteEmailTemplate().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['page'] != null) {
-            queryParameters['page'] = requestParameters['page'];
-        }
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
-        }
-        if (requestParameters['skip'] != null) {
-            queryParameters['skip'] = requestParameters['skip'];
-        }
-        if (requestParameters['asTree'] != null) {
-            queryParameters['asTree'] = requestParameters['asTree'];
-        }
-        if (requestParameters['skipChildren'] != null) {
-            queryParameters['skipChildren'] = requestParameters['skipChildren'];
-        }
-        if (requestParameters['limitChildren'] != null) {
-            queryParameters['limitChildren'] = requestParameters['limitChildren'];
-        }
-        if (requestParameters['maxTreeDepth'] != null) {
-            queryParameters['maxTreeDepth'] = requestParameters['maxTreeDepth'];
-        }
-        if (requestParameters['urlId'] != null) {
-            queryParameters['urlId'] = requestParameters['urlId'];
-        }
-        if (requestParameters['userId'] != null) {
-            queryParameters['userId'] = requestParameters['userId'];
-        }
-        if (requestParameters['anonUserId'] != null) {
-            queryParameters['anonUserId'] = requestParameters['anonUserId'];
-        }
-        if (requestParameters['contextUserId'] != null) {
-            queryParameters['contextUserId'] = requestParameters['contextUserId'];
-        }
-        if (requestParameters['hashTag'] != null) {
-            queryParameters['hashTag'] = requestParameters['hashTag'];
-        }
-        if (requestParameters['parentId'] != null) {
-            queryParameters['parentId'] = requestParameters['parentId'];
-        }
-        if (requestParameters['direction'] != null) {
-            queryParameters['direction'] = requestParameters['direction'];
-        }
         const headerParameters = {};
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/comments`,
-            method: 'GET',
+            path: `/api/v1/email-templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetComments200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getComments(requestParameters, initOverrides) {
-        const response = await this.getCommentsRaw(requestParameters, initOverrides);
+    async deleteEmailTemplate(requestParameters, initOverrides) {
+        const response = await this.deleteEmailTemplateRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getDomainConfigRaw(requestParameters, initOverrides) {
+    async deleteEmailTemplateRenderErrorRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getDomainConfig().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteEmailTemplateRenderError().');
         }
-        if (requestParameters['domain'] == null) {
-            throw new runtime.RequiredError('domain', 'Required parameter "domain" was null or undefined when calling getDomainConfig().');
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteEmailTemplateRenderError().');
+        }
+        if (requestParameters['errorId'] == null) {
+            throw new runtime.RequiredError('errorId', 'Required parameter "errorId" was null or undefined when calling deleteEmailTemplateRenderError().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
@@ -880,125 +931,122 @@ class DefaultApi extends runtime.BaseAPI {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/domain-configs/{domain}`.replace(`{${"domain"}}`, encodeURIComponent(String(requestParameters['domain']))),
-            method: 'GET',
+            path: `/api/v1/email-templates/{id}/render-errors/{errorId}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))).replace(`{${"errorId"}}`, encodeURIComponent(String(requestParameters['errorId']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetDomainConfig200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getDomainConfig(requestParameters, initOverrides) {
-        const response = await this.getDomainConfigRaw(requestParameters, initOverrides);
+    async deleteEmailTemplateRenderError(requestParameters, initOverrides) {
+        const response = await this.deleteEmailTemplateRenderErrorRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getDomainConfigsRaw(requestParameters, initOverrides) {
-        if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getDomainConfigs().');
+    async deleteHashTagRaw(requestParameters, initOverrides) {
+        if (requestParameters['tag'] == null) {
+            throw new runtime.RequiredError('tag', 'Required parameter "tag" was null or undefined when calling deleteHashTag().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/domain-configs`,
-            method: 'GET',
+            path: `/api/v1/hash-tags/{tag}`.replace(`{${"tag"}}`, encodeURIComponent(String(requestParameters['tag']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.DeleteHashTagRequestToJSON)(requestParameters['deleteHashTagRequest']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetDomainConfigs200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getDomainConfigs(requestParameters, initOverrides) {
-        const response = await this.getDomainConfigsRaw(requestParameters, initOverrides);
+    async deleteHashTag(requestParameters, initOverrides) {
+        const response = await this.deleteHashTagRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
-     *  req tenantId afterId
      */
-    async getFeedPostsRaw(requestParameters, initOverrides) {
+    async deleteModeratorRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getFeedPosts().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteModerator().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteModerator().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['afterId'] != null) {
-            queryParameters['afterId'] = requestParameters['afterId'];
-        }
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
-        }
-        if (requestParameters['tags'] != null) {
-            queryParameters['tags'] = requestParameters['tags'];
+        if (requestParameters['sendEmail'] != null) {
+            queryParameters['sendEmail'] = requestParameters['sendEmail'];
         }
         const headerParameters = {};
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/feed-posts`,
-            method: 'GET',
+            path: `/api/v1/moderators/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetFeedPosts200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
-     *  req tenantId afterId
      */
-    async getFeedPosts(requestParameters, initOverrides) {
-        const response = await this.getFeedPostsRaw(requestParameters, initOverrides);
+    async deleteModerator(requestParameters, initOverrides) {
+        const response = await this.deleteModeratorRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getPageByURLIdRaw(requestParameters, initOverrides) {
+    async deleteNotificationCountRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getPageByURLId().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteNotificationCount().');
         }
-        if (requestParameters['urlId'] == null) {
-            throw new runtime.RequiredError('urlId', 'Required parameter "urlId" was null or undefined when calling getPageByURLId().');
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteNotificationCount().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['urlId'] != null) {
-            queryParameters['urlId'] = requestParameters['urlId'];
-        }
         const headerParameters = {};
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/pages/by-url-id`,
-            method: 'GET',
+            path: `/api/v1/notification-count/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetPageByURLIdAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getPageByURLId(requestParameters, initOverrides) {
-        const response = await this.getPageByURLIdRaw(requestParameters, initOverrides);
+    async deleteNotificationCount(requestParameters, initOverrides) {
+        const response = await this.deleteNotificationCountRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getPagesRaw(requestParameters, initOverrides) {
+    async deletePageRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getPages().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deletePage().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deletePage().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
@@ -1009,27 +1057,27 @@ class DefaultApi extends runtime.BaseAPI {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/pages`,
-            method: 'GET',
+            path: `/api/v1/pages/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetPagesAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeletePageAPIResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getPages(requestParameters, initOverrides) {
-        const response = await this.getPagesRaw(requestParameters, initOverrides);
+    async deletePage(requestParameters, initOverrides) {
+        const response = await this.deletePageRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getSSOUserByEmailRaw(requestParameters, initOverrides) {
+    async deletePendingWebhookEventRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getSSOUserByEmail().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deletePendingWebhookEvent().');
         }
-        if (requestParameters['email'] == null) {
-            throw new runtime.RequiredError('email', 'Required parameter "email" was null or undefined when calling getSSOUserByEmail().');
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deletePendingWebhookEvent().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
@@ -1040,27 +1088,27 @@ class DefaultApi extends runtime.BaseAPI {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/sso-users/by-email/{email}`.replace(`{${"email"}}`, encodeURIComponent(String(requestParameters['email']))),
-            method: 'GET',
+            path: `/api/v1/pending-webhook-events/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetSSOUserByEmailAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getSSOUserByEmail(requestParameters, initOverrides) {
-        const response = await this.getSSOUserByEmailRaw(requestParameters, initOverrides);
+    async deletePendingWebhookEvent(requestParameters, initOverrides) {
+        const response = await this.deletePendingWebhookEventRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getSSOUserByIdRaw(requestParameters, initOverrides) {
+    async deleteQuestionConfigRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getSSOUserById().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteQuestionConfig().');
         }
         if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getSSOUserById().');
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteQuestionConfig().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
@@ -1071,151 +1119,163 @@ class DefaultApi extends runtime.BaseAPI {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/sso-users/by-id/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'GET',
+            path: `/api/v1/question-configs/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetSSOUserByIdAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getSSOUserById(requestParameters, initOverrides) {
-        const response = await this.getSSOUserByIdRaw(requestParameters, initOverrides);
+    async deleteQuestionConfig(requestParameters, initOverrides) {
+        const response = await this.deleteQuestionConfigRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getSSOUsersRaw(requestParameters, initOverrides) {
+    async deleteQuestionResultRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getSSOUsers().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteQuestionResult().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteQuestionResult().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['skip'] != null) {
-            queryParameters['skip'] = requestParameters['skip'];
-        }
         const headerParameters = {};
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/sso-users`,
-            method: 'GET',
+            path: `/api/v1/question-results/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetSSOUsers200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getSSOUsers(requestParameters, initOverrides) {
-        const response = await this.getSSOUsersRaw(requestParameters, initOverrides);
+    async deleteQuestionResult(requestParameters, initOverrides) {
+        const response = await this.deleteQuestionResultRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getSubscriptionsRaw(requestParameters, initOverrides) {
+    async deleteSSOUserRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getSubscriptions().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteSSOUser().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteSSOUser().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['userId'] != null) {
-            queryParameters['userId'] = requestParameters['userId'];
+        if (requestParameters['deleteComments'] != null) {
+            queryParameters['deleteComments'] = requestParameters['deleteComments'];
+        }
+        if (requestParameters['commentDeleteMode'] != null) {
+            queryParameters['commentDeleteMode'] = requestParameters['commentDeleteMode'];
         }
         const headerParameters = {};
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/subscriptions`,
-            method: 'GET',
+            path: `/api/v1/sso-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetSubscriptionsAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeleteSSOUserAPIResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getSubscriptions(requestParameters, initOverrides) {
-        const response = await this.getSubscriptionsRaw(requestParameters, initOverrides);
+    async deleteSSOUser(requestParameters, initOverrides) {
+        const response = await this.deleteSSOUserRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getUserBadgeRaw(requestParameters, initOverrides) {
+    async deleteSubscriptionRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getUserBadge().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteSubscription().');
         }
         if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getUserBadge().');
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteSubscription().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
         const headerParameters = {};
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/user-badges/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'GET',
+            path: `/api/v1/subscriptions/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUserBadge200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeleteSubscriptionAPIResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getUserBadge(requestParameters, initOverrides) {
-        const response = await this.getUserBadgeRaw(requestParameters, initOverrides);
+    async deleteSubscription(requestParameters, initOverrides) {
+        const response = await this.deleteSubscriptionRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getUserBadgeProgressByIdRaw(requestParameters, initOverrides) {
+    async deleteTenantRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getUserBadgeProgressById().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteTenant().');
         }
         if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getUserBadgeProgressById().');
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteTenant().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
+        if (requestParameters['sure'] != null) {
+            queryParameters['sure'] = requestParameters['sure'];
+        }
         const headerParameters = {};
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/user-badge-progress/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'GET',
+            path: `/api/v1/tenants/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUserBadgeProgressById200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getUserBadgeProgressById(requestParameters, initOverrides) {
-        const response = await this.getUserBadgeProgressByIdRaw(requestParameters, initOverrides);
+    async deleteTenant(requestParameters, initOverrides) {
+        const response = await this.deleteTenantRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getUserBadgeProgressByUserIdRaw(requestParameters, initOverrides) {
+    async deleteTenantPackageRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getUserBadgeProgressByUserId().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteTenantPackage().');
         }
-        if (requestParameters['userId'] == null) {
-            throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling getUserBadgeProgressByUserId().');
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteTenantPackage().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
@@ -1226,61 +1286,2166 @@ class DefaultApi extends runtime.BaseAPI {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/user-badge-progress/user/{userId}`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
-            method: 'GET',
+            path: `/api/v1/tenant-packages/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUserBadgeProgressById200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getUserBadgeProgressByUserId(requestParameters, initOverrides) {
-        const response = await this.getUserBadgeProgressByUserIdRaw(requestParameters, initOverrides);
+    async deleteTenantPackage(requestParameters, initOverrides) {
+        const response = await this.deleteTenantPackageRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getUserBadgeProgressListRaw(requestParameters, initOverrides) {
+    async deleteTenantUserRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getUserBadgeProgressList().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteTenantUser().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteTenantUser().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['userId'] != null) {
-            queryParameters['userId'] = requestParameters['userId'];
-        }
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
+        if (requestParameters['deleteComments'] != null) {
+            queryParameters['deleteComments'] = requestParameters['deleteComments'];
         }
-        if (requestParameters['skip'] != null) {
-            queryParameters['skip'] = requestParameters['skip'];
+        if (requestParameters['commentDeleteMode'] != null) {
+            queryParameters['commentDeleteMode'] = requestParameters['commentDeleteMode'];
         }
         const headerParameters = {};
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/user-badge-progress`,
-            method: 'GET',
+            path: `/api/v1/tenant-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
             headers: headerParameters,
             query: queryParameters,
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUserBadgeProgressList200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getUserBadgeProgressList(requestParameters, initOverrides) {
-        const response = await this.getUserBadgeProgressListRaw(requestParameters, initOverrides);
+    async deleteTenantUser(requestParameters, initOverrides) {
+        const response = await this.deleteTenantUserRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async getUserBadgesRaw(requestParameters, initOverrides) {
+    async deleteUserBadgeRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getUserBadges().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteUserBadge().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteUserBadge().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/user-badges/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.UpdateUserBadge200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async deleteUserBadge(requestParameters, initOverrides) {
+        const response = await this.deleteUserBadgeRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async deleteVoteRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling deleteVote().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling deleteVote().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['editKey'] != null) {
+            queryParameters['editKey'] = requestParameters['editKey'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/votes/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'DELETE',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.DeleteVote200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async deleteVote(requestParameters, initOverrides) {
+        const response = await this.deleteVoteRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async flagCommentRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling flagComment().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling flagComment().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
+        if (requestParameters['anonUserId'] != null) {
+            queryParameters['anonUserId'] = requestParameters['anonUserId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/comments/{id}/flag`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagComment200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async flagComment(requestParameters, initOverrides) {
+        const response = await this.flagCommentRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getAuditLogsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getAuditLogs().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        if (requestParameters['order'] != null) {
+            queryParameters['order'] = requestParameters['order'];
+        }
+        if (requestParameters['after'] != null) {
+            queryParameters['after'] = requestParameters['after'];
+        }
+        if (requestParameters['before'] != null) {
+            queryParameters['before'] = requestParameters['before'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/audit-logs`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetAuditLogs200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getAuditLogs(requestParameters, initOverrides) {
+        const response = await this.getAuditLogsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getCachedNotificationCountRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getCachedNotificationCount().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getCachedNotificationCount().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/notification-count/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetCachedNotificationCount200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getCachedNotificationCount(requestParameters, initOverrides) {
+        const response = await this.getCachedNotificationCountRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getCommentRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getComment().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getComment().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/comments/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetComment200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getComment(requestParameters, initOverrides) {
+        const response = await this.getCommentRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getCommentsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getComments().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        if (requestParameters['asTree'] != null) {
+            queryParameters['asTree'] = requestParameters['asTree'];
+        }
+        if (requestParameters['skipChildren'] != null) {
+            queryParameters['skipChildren'] = requestParameters['skipChildren'];
+        }
+        if (requestParameters['limitChildren'] != null) {
+            queryParameters['limitChildren'] = requestParameters['limitChildren'];
+        }
+        if (requestParameters['maxTreeDepth'] != null) {
+            queryParameters['maxTreeDepth'] = requestParameters['maxTreeDepth'];
+        }
+        if (requestParameters['urlId'] != null) {
+            queryParameters['urlId'] = requestParameters['urlId'];
+        }
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
+        if (requestParameters['anonUserId'] != null) {
+            queryParameters['anonUserId'] = requestParameters['anonUserId'];
+        }
+        if (requestParameters['contextUserId'] != null) {
+            queryParameters['contextUserId'] = requestParameters['contextUserId'];
+        }
+        if (requestParameters['hashTag'] != null) {
+            queryParameters['hashTag'] = requestParameters['hashTag'];
+        }
+        if (requestParameters['parentId'] != null) {
+            queryParameters['parentId'] = requestParameters['parentId'];
+        }
+        if (requestParameters['direction'] != null) {
+            queryParameters['direction'] = requestParameters['direction'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/comments`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetComments200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getComments(requestParameters, initOverrides) {
+        const response = await this.getCommentsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getDomainConfigRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getDomainConfig().');
+        }
+        if (requestParameters['domain'] == null) {
+            throw new runtime.RequiredError('domain', 'Required parameter "domain" was null or undefined when calling getDomainConfig().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/domain-configs/{domain}`.replace(`{${"domain"}}`, encodeURIComponent(String(requestParameters['domain']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetDomainConfig200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getDomainConfig(requestParameters, initOverrides) {
+        const response = await this.getDomainConfigRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getDomainConfigsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getDomainConfigs().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/domain-configs`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetDomainConfigs200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getDomainConfigs(requestParameters, initOverrides) {
+        const response = await this.getDomainConfigsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getEmailTemplateRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getEmailTemplate().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getEmailTemplate().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/email-templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetEmailTemplate200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getEmailTemplate(requestParameters, initOverrides) {
+        const response = await this.getEmailTemplateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getEmailTemplateDefinitionsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getEmailTemplateDefinitions().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/email-templates/definitions`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetEmailTemplateDefinitions200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getEmailTemplateDefinitions(requestParameters, initOverrides) {
+        const response = await this.getEmailTemplateDefinitionsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getEmailTemplateRenderErrorsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getEmailTemplateRenderErrors().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getEmailTemplateRenderErrors().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/email-templates/{id}/render-errors`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetEmailTemplateRenderErrors200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getEmailTemplateRenderErrors(requestParameters, initOverrides) {
+        const response = await this.getEmailTemplateRenderErrorsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getEmailTemplatesRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getEmailTemplates().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/email-templates`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetEmailTemplates200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getEmailTemplates(requestParameters, initOverrides) {
+        const response = await this.getEmailTemplatesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     *  req tenantId afterId
+     */
+    async getFeedPostsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getFeedPosts().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['afterId'] != null) {
+            queryParameters['afterId'] = requestParameters['afterId'];
+        }
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+        if (requestParameters['tags'] != null) {
+            queryParameters['tags'] = requestParameters['tags'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/feed-posts`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetFeedPosts200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     *  req tenantId afterId
+     */
+    async getFeedPosts(requestParameters, initOverrides) {
+        const response = await this.getFeedPostsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getHashTagsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getHashTags().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['page'] != null) {
+            queryParameters['page'] = requestParameters['page'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/hash-tags`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetHashTags200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getHashTags(requestParameters, initOverrides) {
+        const response = await this.getHashTagsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getModeratorRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getModerator().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getModerator().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/moderators/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetModerator200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getModerator(requestParameters, initOverrides) {
+        const response = await this.getModeratorRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getModeratorsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getModerators().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/moderators`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetModerators200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getModerators(requestParameters, initOverrides) {
+        const response = await this.getModeratorsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getNotificationCountRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getNotificationCount().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
+        if (requestParameters['urlId'] != null) {
+            queryParameters['urlId'] = requestParameters['urlId'];
+        }
+        if (requestParameters['fromCommentId'] != null) {
+            queryParameters['fromCommentId'] = requestParameters['fromCommentId'];
+        }
+        if (requestParameters['viewed'] != null) {
+            queryParameters['viewed'] = requestParameters['viewed'];
+        }
+        if (requestParameters['type'] != null) {
+            queryParameters['type'] = requestParameters['type'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/notifications/count`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetNotificationCount200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getNotificationCount(requestParameters, initOverrides) {
+        const response = await this.getNotificationCountRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getNotificationsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getNotifications().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
+        if (requestParameters['urlId'] != null) {
+            queryParameters['urlId'] = requestParameters['urlId'];
+        }
+        if (requestParameters['fromCommentId'] != null) {
+            queryParameters['fromCommentId'] = requestParameters['fromCommentId'];
+        }
+        if (requestParameters['viewed'] != null) {
+            queryParameters['viewed'] = requestParameters['viewed'];
+        }
+        if (requestParameters['type'] != null) {
+            queryParameters['type'] = requestParameters['type'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/notifications`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetNotifications200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getNotifications(requestParameters, initOverrides) {
+        const response = await this.getNotificationsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getPageByURLIdRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getPageByURLId().');
+        }
+        if (requestParameters['urlId'] == null) {
+            throw new runtime.RequiredError('urlId', 'Required parameter "urlId" was null or undefined when calling getPageByURLId().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['urlId'] != null) {
+            queryParameters['urlId'] = requestParameters['urlId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/pages/by-url-id`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetPageByURLIdAPIResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getPageByURLId(requestParameters, initOverrides) {
+        const response = await this.getPageByURLIdRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getPagesRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getPages().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/pages`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetPagesAPIResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getPages(requestParameters, initOverrides) {
+        const response = await this.getPagesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getPendingWebhookEventCountRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getPendingWebhookEventCount().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['commentId'] != null) {
+            queryParameters['commentId'] = requestParameters['commentId'];
+        }
+        if (requestParameters['externalId'] != null) {
+            queryParameters['externalId'] = requestParameters['externalId'];
+        }
+        if (requestParameters['eventType'] != null) {
+            queryParameters['eventType'] = requestParameters['eventType'];
+        }
+        if (requestParameters['type'] != null) {
+            queryParameters['type'] = requestParameters['type'];
+        }
+        if (requestParameters['domain'] != null) {
+            queryParameters['domain'] = requestParameters['domain'];
+        }
+        if (requestParameters['attemptCountGT'] != null) {
+            queryParameters['attemptCountGT'] = requestParameters['attemptCountGT'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/pending-webhook-events/count`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetPendingWebhookEventCount200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getPendingWebhookEventCount(requestParameters, initOverrides) {
+        const response = await this.getPendingWebhookEventCountRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getPendingWebhookEventsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getPendingWebhookEvents().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['commentId'] != null) {
+            queryParameters['commentId'] = requestParameters['commentId'];
+        }
+        if (requestParameters['externalId'] != null) {
+            queryParameters['externalId'] = requestParameters['externalId'];
+        }
+        if (requestParameters['eventType'] != null) {
+            queryParameters['eventType'] = requestParameters['eventType'];
+        }
+        if (requestParameters['type'] != null) {
+            queryParameters['type'] = requestParameters['type'];
+        }
+        if (requestParameters['domain'] != null) {
+            queryParameters['domain'] = requestParameters['domain'];
+        }
+        if (requestParameters['attemptCountGT'] != null) {
+            queryParameters['attemptCountGT'] = requestParameters['attemptCountGT'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/pending-webhook-events`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetPendingWebhookEvents200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getPendingWebhookEvents(requestParameters, initOverrides) {
+        const response = await this.getPendingWebhookEventsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getQuestionConfigRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getQuestionConfig().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getQuestionConfig().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/question-configs/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetQuestionConfig200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getQuestionConfig(requestParameters, initOverrides) {
+        const response = await this.getQuestionConfigRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getQuestionConfigsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getQuestionConfigs().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/question-configs`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetQuestionConfigs200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getQuestionConfigs(requestParameters, initOverrides) {
+        const response = await this.getQuestionConfigsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getQuestionResultRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getQuestionResult().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getQuestionResult().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/question-results/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetQuestionResult200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getQuestionResult(requestParameters, initOverrides) {
+        const response = await this.getQuestionResultRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getQuestionResultsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getQuestionResults().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['urlId'] != null) {
+            queryParameters['urlId'] = requestParameters['urlId'];
+        }
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
+        if (requestParameters['startDate'] != null) {
+            queryParameters['startDate'] = requestParameters['startDate'];
+        }
+        if (requestParameters['questionId'] != null) {
+            queryParameters['questionId'] = requestParameters['questionId'];
+        }
+        if (requestParameters['questionIds'] != null) {
+            queryParameters['questionIds'] = requestParameters['questionIds'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/question-results`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetQuestionResults200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getQuestionResults(requestParameters, initOverrides) {
+        const response = await this.getQuestionResultsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getSSOUserByEmailRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getSSOUserByEmail().');
+        }
+        if (requestParameters['email'] == null) {
+            throw new runtime.RequiredError('email', 'Required parameter "email" was null or undefined when calling getSSOUserByEmail().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/sso-users/by-email/{email}`.replace(`{${"email"}}`, encodeURIComponent(String(requestParameters['email']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetSSOUserByEmailAPIResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getSSOUserByEmail(requestParameters, initOverrides) {
+        const response = await this.getSSOUserByEmailRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getSSOUserByIdRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getSSOUserById().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getSSOUserById().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/sso-users/by-id/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetSSOUserByIdAPIResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getSSOUserById(requestParameters, initOverrides) {
+        const response = await this.getSSOUserByIdRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getSSOUsersRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getSSOUsers().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/sso-users`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetSSOUsers200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getSSOUsers(requestParameters, initOverrides) {
+        const response = await this.getSSOUsersRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getSubscriptionsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getSubscriptions().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/subscriptions`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetSubscriptionsAPIResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getSubscriptions(requestParameters, initOverrides) {
+        const response = await this.getSubscriptionsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getTenantRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getTenant().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getTenant().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/tenants/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetTenant200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getTenant(requestParameters, initOverrides) {
+        const response = await this.getTenantRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getTenantDailyUsagesRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getTenantDailyUsages().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['yearNumber'] != null) {
+            queryParameters['yearNumber'] = requestParameters['yearNumber'];
+        }
+        if (requestParameters['monthNumber'] != null) {
+            queryParameters['monthNumber'] = requestParameters['monthNumber'];
+        }
+        if (requestParameters['dayNumber'] != null) {
+            queryParameters['dayNumber'] = requestParameters['dayNumber'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/tenant-daily-usage`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetTenantDailyUsages200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getTenantDailyUsages(requestParameters, initOverrides) {
+        const response = await this.getTenantDailyUsagesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getTenantPackageRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getTenantPackage().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getTenantPackage().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/tenant-packages/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetTenantPackage200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getTenantPackage(requestParameters, initOverrides) {
+        const response = await this.getTenantPackageRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getTenantPackagesRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getTenantPackages().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/tenant-packages`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetTenantPackages200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getTenantPackages(requestParameters, initOverrides) {
+        const response = await this.getTenantPackagesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getTenantUserRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getTenantUser().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getTenantUser().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/tenant-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetTenantUser200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getTenantUser(requestParameters, initOverrides) {
+        const response = await this.getTenantUserRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getTenantUsersRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getTenantUsers().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/tenant-users`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetTenantUsers200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getTenantUsers(requestParameters, initOverrides) {
+        const response = await this.getTenantUsersRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getTenantsRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getTenants().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['meta'] != null) {
+            queryParameters['meta'] = requestParameters['meta'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/tenants`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetTenants200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getTenants(requestParameters, initOverrides) {
+        const response = await this.getTenantsRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getUserRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getUser().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getUser().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUser200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getUser(requestParameters, initOverrides) {
+        const response = await this.getUserRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getUserBadgeRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getUserBadge().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getUserBadge().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/user-badges/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUserBadge200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getUserBadge(requestParameters, initOverrides) {
+        const response = await this.getUserBadgeRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getUserBadgeProgressByIdRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getUserBadgeProgressById().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling getUserBadgeProgressById().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/user-badge-progress/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUserBadgeProgressById200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getUserBadgeProgressById(requestParameters, initOverrides) {
+        const response = await this.getUserBadgeProgressByIdRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getUserBadgeProgressByUserIdRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getUserBadgeProgressByUserId().');
+        }
+        if (requestParameters['userId'] == null) {
+            throw new runtime.RequiredError('userId', 'Required parameter "userId" was null or undefined when calling getUserBadgeProgressByUserId().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/user-badge-progress/user/{userId}`.replace(`{${"userId"}}`, encodeURIComponent(String(requestParameters['userId']))),
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUserBadgeProgressById200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getUserBadgeProgressByUserId(requestParameters, initOverrides) {
+        const response = await this.getUserBadgeProgressByUserIdRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getUserBadgeProgressListRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getUserBadgeProgressList().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/user-badge-progress`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUserBadgeProgressList200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getUserBadgeProgressList(requestParameters, initOverrides) {
+        const response = await this.getUserBadgeProgressListRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getUserBadgesRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getUserBadges().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
+        if (requestParameters['badgeId'] != null) {
+            queryParameters['badgeId'] = requestParameters['badgeId'];
+        }
+        if (requestParameters['type'] != null) {
+            queryParameters['type'] = requestParameters['type'];
+        }
+        if (requestParameters['displayedOnComments'] != null) {
+            queryParameters['displayedOnComments'] = requestParameters['displayedOnComments'];
+        }
+        if (requestParameters['limit'] != null) {
+            queryParameters['limit'] = requestParameters['limit'];
+        }
+        if (requestParameters['skip'] != null) {
+            queryParameters['skip'] = requestParameters['skip'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/user-badges`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUserBadges200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getUserBadges(requestParameters, initOverrides) {
+        const response = await this.getUserBadgesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getVotesRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getVotes().');
+        }
+        if (requestParameters['urlId'] == null) {
+            throw new runtime.RequiredError('urlId', 'Required parameter "urlId" was null or undefined when calling getVotes().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['urlId'] != null) {
+            queryParameters['urlId'] = requestParameters['urlId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/votes`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetVotes200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getVotes(requestParameters, initOverrides) {
+        const response = await this.getVotesRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async getVotesForUserRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling getVotesForUser().');
+        }
+        if (requestParameters['urlId'] == null) {
+            throw new runtime.RequiredError('urlId', 'Required parameter "urlId" was null or undefined when calling getVotesForUser().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['urlId'] != null) {
+            queryParameters['urlId'] = requestParameters['urlId'];
+        }
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
+        if (requestParameters['anonUserId'] != null) {
+            queryParameters['anonUserId'] = requestParameters['anonUserId'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/votes/for-user`,
+            method: 'GET',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetVotesForUser200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async getVotesForUser(requestParameters, initOverrides) {
+        const response = await this.getVotesForUserRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async patchDomainConfigRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling patchDomainConfig().');
+        }
+        if (requestParameters['domainToUpdate'] == null) {
+            throw new runtime.RequiredError('domainToUpdate', 'Required parameter "domainToUpdate" was null or undefined when calling patchDomainConfig().');
+        }
+        if (requestParameters['patchDomainConfigParams'] == null) {
+            throw new runtime.RequiredError('patchDomainConfigParams', 'Required parameter "patchDomainConfigParams" was null or undefined when calling patchDomainConfig().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/domain-configs/{domainToUpdate}`.replace(`{${"domainToUpdate"}}`, encodeURIComponent(String(requestParameters['domainToUpdate']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.PatchDomainConfigParamsToJSON)(requestParameters['patchDomainConfigParams']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetDomainConfig200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async patchDomainConfig(requestParameters, initOverrides) {
+        const response = await this.patchDomainConfigRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async patchHashTagRaw(requestParameters, initOverrides) {
+        if (requestParameters['tag'] == null) {
+            throw new runtime.RequiredError('tag', 'Required parameter "tag" was null or undefined when calling patchHashTag().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/hash-tags/{tag}`.replace(`{${"tag"}}`, encodeURIComponent(String(requestParameters['tag']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.UpdateHashTagBodyToJSON)(requestParameters['updateHashTagBody']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.PatchHashTag200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async patchHashTag(requestParameters, initOverrides) {
+        const response = await this.patchHashTagRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async patchPageRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling patchPage().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling patchPage().');
+        }
+        if (requestParameters['updateAPIPageData'] == null) {
+            throw new runtime.RequiredError('updateAPIPageData', 'Required parameter "updateAPIPageData" was null or undefined when calling patchPage().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/pages/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.UpdateAPIPageDataToJSON)(requestParameters['updateAPIPageData']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.PatchPageAPIResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async patchPage(requestParameters, initOverrides) {
+        const response = await this.patchPageRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async patchSSOUserRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling patchSSOUser().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling patchSSOUser().');
+        }
+        if (requestParameters['updateAPISSOUserData'] == null) {
+            throw new runtime.RequiredError('updateAPISSOUserData', 'Required parameter "updateAPISSOUserData" was null or undefined when calling patchSSOUser().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['updateComments'] != null) {
+            queryParameters['updateComments'] = requestParameters['updateComments'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/sso-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.UpdateAPISSOUserDataToJSON)(requestParameters['updateAPISSOUserData']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.PatchSSOUserAPIResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async patchSSOUser(requestParameters, initOverrides) {
+        const response = await this.patchSSOUserRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async putDomainConfigRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling putDomainConfig().');
+        }
+        if (requestParameters['domainToUpdate'] == null) {
+            throw new runtime.RequiredError('domainToUpdate', 'Required parameter "domainToUpdate" was null or undefined when calling putDomainConfig().');
+        }
+        if (requestParameters['updateDomainConfigParams'] == null) {
+            throw new runtime.RequiredError('updateDomainConfigParams', 'Required parameter "updateDomainConfigParams" was null or undefined when calling putDomainConfig().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/domain-configs/{domainToUpdate}`.replace(`{${"domainToUpdate"}}`, encodeURIComponent(String(requestParameters['domainToUpdate']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.UpdateDomainConfigParamsToJSON)(requestParameters['updateDomainConfigParams']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetDomainConfig200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async putDomainConfig(requestParameters, initOverrides) {
+        const response = await this.putDomainConfigRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async putSSOUserRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling putSSOUser().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling putSSOUser().');
+        }
+        if (requestParameters['updateAPISSOUserData'] == null) {
+            throw new runtime.RequiredError('updateAPISSOUserData', 'Required parameter "updateAPISSOUserData" was null or undefined when calling putSSOUser().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['updateComments'] != null) {
+            queryParameters['updateComments'] = requestParameters['updateComments'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/sso-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.UpdateAPISSOUserDataToJSON)(requestParameters['updateAPISSOUserData']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.PutSSOUserAPIResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async putSSOUser(requestParameters, initOverrides) {
+        const response = await this.putSSOUserRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async renderEmailTemplateRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling renderEmailTemplate().');
+        }
+        if (requestParameters['renderEmailTemplateBody'] == null) {
+            throw new runtime.RequiredError('renderEmailTemplateBody', 'Required parameter "renderEmailTemplateBody" was null or undefined when calling renderEmailTemplate().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['locale'] != null) {
+            queryParameters['locale'] = requestParameters['locale'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/email-templates/render`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.RenderEmailTemplateBodyToJSON)(requestParameters['renderEmailTemplateBody']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.RenderEmailTemplate200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async renderEmailTemplate(requestParameters, initOverrides) {
+        const response = await this.renderEmailTemplateRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async replaceTenantPackageRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling replaceTenantPackage().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling replaceTenantPackage().');
+        }
+        if (requestParameters['replaceTenantPackageBody'] == null) {
+            throw new runtime.RequiredError('replaceTenantPackageBody', 'Required parameter "replaceTenantPackageBody" was null or undefined when calling replaceTenantPackage().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/tenant-packages/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.ReplaceTenantPackageBodyToJSON)(requestParameters['replaceTenantPackageBody']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async replaceTenantPackage(requestParameters, initOverrides) {
+        const response = await this.replaceTenantPackageRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async replaceTenantUserRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling replaceTenantUser().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling replaceTenantUser().');
+        }
+        if (requestParameters['replaceTenantUserBody'] == null) {
+            throw new runtime.RequiredError('replaceTenantUserBody', 'Required parameter "replaceTenantUserBody" was null or undefined when calling replaceTenantUser().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['updateComments'] != null) {
+            queryParameters['updateComments'] = requestParameters['updateComments'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/tenant-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PUT',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.ReplaceTenantUserBodyToJSON)(requestParameters['replaceTenantUserBody']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async replaceTenantUser(requestParameters, initOverrides) {
+        const response = await this.replaceTenantUserRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async saveCommentRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling saveComment().');
+        }
+        if (requestParameters['createCommentParams'] == null) {
+            throw new runtime.RequiredError('createCommentParams', 'Required parameter "createCommentParams" was null or undefined when calling saveComment().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['isLive'] != null) {
+            queryParameters['isLive'] = requestParameters['isLive'];
+        }
+        if (requestParameters['doSpamCheck'] != null) {
+            queryParameters['doSpamCheck'] = requestParameters['doSpamCheck'];
+        }
+        if (requestParameters['sendEmails'] != null) {
+            queryParameters['sendEmails'] = requestParameters['sendEmails'];
+        }
+        if (requestParameters['populateNotifications'] != null) {
+            queryParameters['populateNotifications'] = requestParameters['populateNotifications'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/comments`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: (0, index_1.CreateCommentParamsToJSON)(requestParameters['createCommentParams']),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.SaveComment200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async saveComment(requestParameters, initOverrides) {
+        const response = await this.saveCommentRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async saveCommentsBulkRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling saveCommentsBulk().');
+        }
+        if (requestParameters['createCommentParams'] == null) {
+            throw new runtime.RequiredError('createCommentParams', 'Required parameter "createCommentParams" was null or undefined when calling saveCommentsBulk().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['isLive'] != null) {
+            queryParameters['isLive'] = requestParameters['isLive'];
+        }
+        if (requestParameters['doSpamCheck'] != null) {
+            queryParameters['doSpamCheck'] = requestParameters['doSpamCheck'];
+        }
+        if (requestParameters['sendEmails'] != null) {
+            queryParameters['sendEmails'] = requestParameters['sendEmails'];
+        }
+        if (requestParameters['populateNotifications'] != null) {
+            queryParameters['populateNotifications'] = requestParameters['populateNotifications'];
+        }
+        const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/comments/bulk`,
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+            body: requestParameters['createCommentParams'].map(index_1.CreateCommentParamsToJSON),
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.SaveComment200ResponseFromJSON));
+    }
+    /**
+     */
+    async saveCommentsBulk(requestParameters, initOverrides) {
+        const response = await this.saveCommentsBulkRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async sendInviteRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling sendInvite().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling sendInvite().');
+        }
+        if (requestParameters['fromName'] == null) {
+            throw new runtime.RequiredError('fromName', 'Required parameter "fromName" was null or undefined when calling sendInvite().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['fromName'] != null) {
+            queryParameters['fromName'] = requestParameters['fromName'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/moderators/{id}/send-invite`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async sendInvite(requestParameters, initOverrides) {
+        const response = await this.sendInviteRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async sendLoginLinkRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling sendLoginLink().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling sendLoginLink().');
+        }
+        const queryParameters = {};
+        if (requestParameters['tenantId'] != null) {
+            queryParameters['tenantId'] = requestParameters['tenantId'];
+        }
+        if (requestParameters['redirectURL'] != null) {
+            queryParameters['redirectURL'] = requestParameters['redirectURL'];
+        }
+        const headerParameters = {};
+        if (this.configuration && this.configuration.apiKey) {
+            headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
+        }
+        const response = await this.request({
+            path: `/api/v1/tenant-users/{id}/send-login-link`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'POST',
+            headers: headerParameters,
+            query: queryParameters,
+        }, initOverrides);
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
+    }
+    /**
+     */
+    async sendLoginLink(requestParameters, initOverrides) {
+        const response = await this.sendLoginLinkRaw(requestParameters, initOverrides);
+        return await response.value();
+    }
+    /**
+     */
+    async unBlockUserFromCommentRaw(requestParameters, initOverrides) {
+        if (requestParameters['tenantId'] == null) {
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling unBlockUserFromComment().');
+        }
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling unBlockUserFromComment().');
+        }
+        if (requestParameters['unBlockFromCommentParams'] == null) {
+            throw new runtime.RequiredError('unBlockFromCommentParams', 'Required parameter "unBlockFromCommentParams" was null or undefined when calling unBlockUserFromComment().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
@@ -1289,161 +3454,158 @@ class DefaultApi extends runtime.BaseAPI {
         if (requestParameters['userId'] != null) {
             queryParameters['userId'] = requestParameters['userId'];
         }
-        if (requestParameters['badgeId'] != null) {
-            queryParameters['badgeId'] = requestParameters['badgeId'];
-        }
-        if (requestParameters['type'] != null) {
-            queryParameters['type'] = requestParameters['type'];
-        }
-        if (requestParameters['displayedOnComments'] != null) {
-            queryParameters['displayedOnComments'] = requestParameters['displayedOnComments'];
-        }
-        if (requestParameters['limit'] != null) {
-            queryParameters['limit'] = requestParameters['limit'];
-        }
-        if (requestParameters['skip'] != null) {
-            queryParameters['skip'] = requestParameters['skip'];
+        if (requestParameters['anonUserId'] != null) {
+            queryParameters['anonUserId'] = requestParameters['anonUserId'];
         }
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/user-badges`,
-            method: 'GET',
+            path: `/api/v1/comments/{id}/un-block`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.UnBlockFromCommentParamsToJSON)(requestParameters['unBlockFromCommentParams']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetUserBadges200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.UnBlockCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async getUserBadges(requestParameters, initOverrides) {
-        const response = await this.getUserBadgesRaw(requestParameters, initOverrides);
+    async unBlockUserFromComment(requestParameters, initOverrides) {
+        const response = await this.unBlockUserFromCommentRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async patchDomainConfigRaw(requestParameters, initOverrides) {
+    async unFlagCommentRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling patchDomainConfig().');
-        }
-        if (requestParameters['domainToUpdate'] == null) {
-            throw new runtime.RequiredError('domainToUpdate', 'Required parameter "domainToUpdate" was null or undefined when calling patchDomainConfig().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling unFlagComment().');
         }
-        if (requestParameters['patchDomainConfigParams'] == null) {
-            throw new runtime.RequiredError('patchDomainConfigParams', 'Required parameter "patchDomainConfigParams" was null or undefined when calling patchDomainConfig().');
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling unFlagComment().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
+        }
+        if (requestParameters['anonUserId'] != null) {
+            queryParameters['anonUserId'] = requestParameters['anonUserId'];
+        }
         const headerParameters = {};
-        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/domain-configs/{domainToUpdate}`.replace(`{${"domainToUpdate"}}`, encodeURIComponent(String(requestParameters['domainToUpdate']))),
-            method: 'PATCH',
+            path: `/api/v1/comments/{id}/un-flag`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'POST',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.PatchDomainConfigParamsToJSON)(requestParameters['patchDomainConfigParams']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetDomainConfig200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagComment200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async patchDomainConfig(requestParameters, initOverrides) {
-        const response = await this.patchDomainConfigRaw(requestParameters, initOverrides);
+    async unFlagComment(requestParameters, initOverrides) {
+        const response = await this.unFlagCommentRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async patchPageRaw(requestParameters, initOverrides) {
+    async updateCommentRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling patchPage().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateComment().');
         }
         if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling patchPage().');
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateComment().');
         }
-        if (requestParameters['updateAPIPageData'] == null) {
-            throw new runtime.RequiredError('updateAPIPageData', 'Required parameter "updateAPIPageData" was null or undefined when calling patchPage().');
+        if (requestParameters['updatableCommentParams'] == null) {
+            throw new runtime.RequiredError('updatableCommentParams', 'Required parameter "updatableCommentParams" was null or undefined when calling updateComment().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
+        if (requestParameters['contextUserId'] != null) {
+            queryParameters['contextUserId'] = requestParameters['contextUserId'];
+        }
+        if (requestParameters['doSpamCheck'] != null) {
+            queryParameters['doSpamCheck'] = requestParameters['doSpamCheck'];
+        }
+        if (requestParameters['isLive'] != null) {
+            queryParameters['isLive'] = requestParameters['isLive'];
+        }
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/pages/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            path: `/api/v1/comments/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.UpdateAPIPageDataToJSON)(requestParameters['updateAPIPageData']),
+            body: (0, index_1.UpdatableCommentParamsToJSON)(requestParameters['updatableCommentParams']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.PatchPageAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async patchPage(requestParameters, initOverrides) {
-        const response = await this.patchPageRaw(requestParameters, initOverrides);
+    async updateComment(requestParameters, initOverrides) {
+        const response = await this.updateCommentRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async patchSSOUserRaw(requestParameters, initOverrides) {
+    async updateEmailTemplateRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling patchSSOUser().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateEmailTemplate().');
         }
         if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling patchSSOUser().');
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateEmailTemplate().');
         }
-        if (requestParameters['updateAPISSOUserData'] == null) {
-            throw new runtime.RequiredError('updateAPISSOUserData', 'Required parameter "updateAPISSOUserData" was null or undefined when calling patchSSOUser().');
+        if (requestParameters['updateEmailTemplateBody'] == null) {
+            throw new runtime.RequiredError('updateEmailTemplateBody', 'Required parameter "updateEmailTemplateBody" was null or undefined when calling updateEmailTemplate().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['updateComments'] != null) {
-            queryParameters['updateComments'] = requestParameters['updateComments'];
-        }
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/sso-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            path: `/api/v1/email-templates/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.UpdateAPISSOUserDataToJSON)(requestParameters['updateAPISSOUserData']),
+            body: (0, index_1.UpdateEmailTemplateBodyToJSON)(requestParameters['updateEmailTemplateBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.PatchSSOUserAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async patchSSOUser(requestParameters, initOverrides) {
-        const response = await this.patchSSOUserRaw(requestParameters, initOverrides);
+    async updateEmailTemplate(requestParameters, initOverrides) {
+        const response = await this.updateEmailTemplateRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async putDomainConfigRaw(requestParameters, initOverrides) {
+    async updateFeedPostRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling putDomainConfig().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateFeedPost().');
         }
-        if (requestParameters['domainToUpdate'] == null) {
-            throw new runtime.RequiredError('domainToUpdate', 'Required parameter "domainToUpdate" was null or undefined when calling putDomainConfig().');
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateFeedPost().');
         }
-        if (requestParameters['updateDomainConfigParams'] == null) {
-            throw new runtime.RequiredError('updateDomainConfigParams', 'Required parameter "updateDomainConfigParams" was null or undefined when calling putDomainConfig().');
+        if (requestParameters['feedPost'] == null) {
+            throw new runtime.RequiredError('feedPost', 'Required parameter "feedPost" was null or undefined when calling updateFeedPost().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
@@ -1455,83 +3617,74 @@ class DefaultApi extends runtime.BaseAPI {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/domain-configs/{domainToUpdate}`.replace(`{${"domainToUpdate"}}`, encodeURIComponent(String(requestParameters['domainToUpdate']))),
-            method: 'PUT',
+            path: `/api/v1/feed-posts/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.UpdateDomainConfigParamsToJSON)(requestParameters['updateDomainConfigParams']),
+            body: (0, index_1.FeedPostToJSON)(requestParameters['feedPost']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.GetDomainConfig200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async putDomainConfig(requestParameters, initOverrides) {
-        const response = await this.putDomainConfigRaw(requestParameters, initOverrides);
+    async updateFeedPost(requestParameters, initOverrides) {
+        const response = await this.updateFeedPostRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async putSSOUserRaw(requestParameters, initOverrides) {
+    async updateModeratorRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling putSSOUser().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateModerator().');
         }
         if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling putSSOUser().');
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateModerator().');
         }
-        if (requestParameters['updateAPISSOUserData'] == null) {
-            throw new runtime.RequiredError('updateAPISSOUserData', 'Required parameter "updateAPISSOUserData" was null or undefined when calling putSSOUser().');
+        if (requestParameters['updateModeratorBody'] == null) {
+            throw new runtime.RequiredError('updateModeratorBody', 'Required parameter "updateModeratorBody" was null or undefined when calling updateModerator().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['updateComments'] != null) {
-            queryParameters['updateComments'] = requestParameters['updateComments'];
-        }
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/sso-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'PUT',
+            path: `/api/v1/moderators/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.UpdateAPISSOUserDataToJSON)(requestParameters['updateAPISSOUserData']),
+            body: (0, index_1.UpdateModeratorBodyToJSON)(requestParameters['updateModeratorBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.PutSSOUserAPIResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async putSSOUser(requestParameters, initOverrides) {
-        const response = await this.putSSOUserRaw(requestParameters, initOverrides);
+    async updateModerator(requestParameters, initOverrides) {
+        const response = await this.updateModeratorRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async saveCommentRaw(requestParameters, initOverrides) {
+    async updateNotificationRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling saveComment().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateNotification().');
         }
-        if (requestParameters['createCommentParams'] == null) {
-            throw new runtime.RequiredError('createCommentParams', 'Required parameter "createCommentParams" was null or undefined when calling saveComment().');
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateNotification().');
+        }
+        if (requestParameters['updateNotificationBody'] == null) {
+            throw new runtime.RequiredError('updateNotificationBody', 'Required parameter "updateNotificationBody" was null or undefined when calling updateNotification().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['isLive'] != null) {
-            queryParameters['isLive'] = requestParameters['isLive'];
-        }
-        if (requestParameters['doSpamCheck'] != null) {
-            queryParameters['doSpamCheck'] = requestParameters['doSpamCheck'];
-        }
-        if (requestParameters['sendEmails'] != null) {
-            queryParameters['sendEmails'] = requestParameters['sendEmails'];
-        }
-        if (requestParameters['populateNotifications'] != null) {
-            queryParameters['populateNotifications'] = requestParameters['populateNotifications'];
+        if (requestParameters['userId'] != null) {
+            queryParameters['userId'] = requestParameters['userId'];
         }
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
@@ -1539,223 +3692,201 @@ class DefaultApi extends runtime.BaseAPI {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/comments`,
-            method: 'POST',
+            path: `/api/v1/notifications/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.CreateCommentParamsToJSON)(requestParameters['createCommentParams']),
+            body: (0, index_1.UpdateNotificationBodyToJSON)(requestParameters['updateNotificationBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.SaveComment200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async saveComment(requestParameters, initOverrides) {
-        const response = await this.saveCommentRaw(requestParameters, initOverrides);
+    async updateNotification(requestParameters, initOverrides) {
+        const response = await this.updateNotificationRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async saveCommentsBulkRaw(requestParameters, initOverrides) {
+    async updateQuestionConfigRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling saveCommentsBulk().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateQuestionConfig().');
         }
-        if (requestParameters['createCommentParams'] == null) {
-            throw new runtime.RequiredError('createCommentParams', 'Required parameter "createCommentParams" was null or undefined when calling saveCommentsBulk().');
+        if (requestParameters['id'] == null) {
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateQuestionConfig().');
+        }
+        if (requestParameters['updateQuestionConfigBody'] == null) {
+            throw new runtime.RequiredError('updateQuestionConfigBody', 'Required parameter "updateQuestionConfigBody" was null or undefined when calling updateQuestionConfig().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['isLive'] != null) {
-            queryParameters['isLive'] = requestParameters['isLive'];
-        }
-        if (requestParameters['doSpamCheck'] != null) {
-            queryParameters['doSpamCheck'] = requestParameters['doSpamCheck'];
-        }
-        if (requestParameters['sendEmails'] != null) {
-            queryParameters['sendEmails'] = requestParameters['sendEmails'];
-        }
-        if (requestParameters['populateNotifications'] != null) {
-            queryParameters['populateNotifications'] = requestParameters['populateNotifications'];
-        }
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/comments/bulk`,
-            method: 'POST',
+            path: `/api/v1/question-configs/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters['createCommentParams'].map(index_1.CreateCommentParamsToJSON),
+            body: (0, index_1.UpdateQuestionConfigBodyToJSON)(requestParameters['updateQuestionConfigBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => jsonValue.map(index_1.SaveComment200ResponseFromJSON));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async saveCommentsBulk(requestParameters, initOverrides) {
-        const response = await this.saveCommentsBulkRaw(requestParameters, initOverrides);
+    async updateQuestionConfig(requestParameters, initOverrides) {
+        const response = await this.updateQuestionConfigRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async unBlockUserFromCommentRaw(requestParameters, initOverrides) {
+    async updateQuestionResultRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling unBlockUserFromComment().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateQuestionResult().');
         }
         if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling unBlockUserFromComment().');
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateQuestionResult().');
         }
-        if (requestParameters['unBlockFromCommentParams'] == null) {
-            throw new runtime.RequiredError('unBlockFromCommentParams', 'Required parameter "unBlockFromCommentParams" was null or undefined when calling unBlockUserFromComment().');
+        if (requestParameters['updateQuestionResultBody'] == null) {
+            throw new runtime.RequiredError('updateQuestionResultBody', 'Required parameter "updateQuestionResultBody" was null or undefined when calling updateQuestionResult().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['userId'] != null) {
-            queryParameters['userId'] = requestParameters['userId'];
-        }
-        if (requestParameters['anonUserId'] != null) {
-            queryParameters['anonUserId'] = requestParameters['anonUserId'];
-        }
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/comments/{id}/un-block`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'POST',
+            path: `/api/v1/question-results/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.UnBlockFromCommentParamsToJSON)(requestParameters['unBlockFromCommentParams']),
+            body: (0, index_1.UpdateQuestionResultBodyToJSON)(requestParameters['updateQuestionResultBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.UnBlockCommentPublic200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async unBlockUserFromComment(requestParameters, initOverrides) {
-        const response = await this.unBlockUserFromCommentRaw(requestParameters, initOverrides);
+    async updateQuestionResult(requestParameters, initOverrides) {
+        const response = await this.updateQuestionResultRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async unFlagCommentRaw(requestParameters, initOverrides) {
+    async updateTenantRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling unFlagComment().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateTenant().');
         }
         if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling unFlagComment().');
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateTenant().');
+        }
+        if (requestParameters['updateTenantBody'] == null) {
+            throw new runtime.RequiredError('updateTenantBody', 'Required parameter "updateTenantBody" was null or undefined when calling updateTenant().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['userId'] != null) {
-            queryParameters['userId'] = requestParameters['userId'];
-        }
-        if (requestParameters['anonUserId'] != null) {
-            queryParameters['anonUserId'] = requestParameters['anonUserId'];
-        }
         const headerParameters = {};
+        headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/comments/{id}/un-flag`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
-            method: 'POST',
+            path: `/api/v1/tenants/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
+            body: (0, index_1.UpdateTenantBodyToJSON)(requestParameters['updateTenantBody']),
         }, initOverrides);
-        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagComment200ResponseFromJSON)(jsonValue));
+        return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async unFlagComment(requestParameters, initOverrides) {
-        const response = await this.unFlagCommentRaw(requestParameters, initOverrides);
+    async updateTenant(requestParameters, initOverrides) {
+        const response = await this.updateTenantRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async updateCommentRaw(requestParameters, initOverrides) {
+    async updateTenantPackageRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateComment().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateTenantPackage().');
         }
         if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateComment().');
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateTenantPackage().');
         }
-        if (requestParameters['body'] == null) {
-            throw new runtime.RequiredError('body', 'Required parameter "body" was null or undefined when calling updateComment().');
+        if (requestParameters['updateTenantPackageBody'] == null) {
+            throw new runtime.RequiredError('updateTenantPackageBody', 'Required parameter "updateTenantPackageBody" was null or undefined when calling updateTenantPackage().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
-        if (requestParameters['contextUserId'] != null) {
-            queryParameters['contextUserId'] = requestParameters['contextUserId'];
-        }
-        if (requestParameters['doSpamCheck'] != null) {
-            queryParameters['doSpamCheck'] = requestParameters['doSpamCheck'];
-        }
-        if (requestParameters['isLive'] != null) {
-            queryParameters['isLive'] = requestParameters['isLive'];
-        }
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/comments/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            path: `/api/v1/tenant-packages/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: requestParameters['body'],
+            body: (0, index_1.UpdateTenantPackageBodyToJSON)(requestParameters['updateTenantPackageBody']),
         }, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async updateComment(requestParameters, initOverrides) {
-        const response = await this.updateCommentRaw(requestParameters, initOverrides);
+    async updateTenantPackage(requestParameters, initOverrides) {
+        const response = await this.updateTenantPackageRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
      */
-    async updateFeedPostRaw(requestParameters, initOverrides) {
+    async updateTenantUserRaw(requestParameters, initOverrides) {
         if (requestParameters['tenantId'] == null) {
-            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateFeedPost().');
+            throw new runtime.RequiredError('tenantId', 'Required parameter "tenantId" was null or undefined when calling updateTenantUser().');
         }
         if (requestParameters['id'] == null) {
-            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateFeedPost().');
+            throw new runtime.RequiredError('id', 'Required parameter "id" was null or undefined when calling updateTenantUser().');
         }
-        if (requestParameters['feedPost'] == null) {
-            throw new runtime.RequiredError('feedPost', 'Required parameter "feedPost" was null or undefined when calling updateFeedPost().');
+        if (requestParameters['updateTenantUserBody'] == null) {
+            throw new runtime.RequiredError('updateTenantUserBody', 'Required parameter "updateTenantUserBody" was null or undefined when calling updateTenantUser().');
         }
         const queryParameters = {};
         if (requestParameters['tenantId'] != null) {
             queryParameters['tenantId'] = requestParameters['tenantId'];
         }
+        if (requestParameters['updateComments'] != null) {
+            queryParameters['updateComments'] = requestParameters['updateComments'];
+        }
         const headerParameters = {};
         headerParameters['Content-Type'] = 'application/json';
         if (this.configuration && this.configuration.apiKey) {
             headerParameters["x-api-key"] = await this.configuration.apiKey("x-api-key"); // api_key authentication
         }
         const response = await this.request({
-            path: `/api/v1/feed-posts/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
+            path: `/api/v1/tenant-users/{id}`.replace(`{${"id"}}`, encodeURIComponent(String(requestParameters['id']))),
             method: 'PATCH',
             headers: headerParameters,
             query: queryParameters,
-            body: (0, index_1.FeedPostToJSON)(requestParameters['feedPost']),
+            body: (0, index_1.UpdateTenantUserBodyToJSON)(requestParameters['updateTenantUserBody']),
         }, initOverrides);
         return new runtime.JSONApiResponse(response, (jsonValue) => (0, index_1.FlagCommentPublic200ResponseFromJSON)(jsonValue));
     }
     /**
      */
-    async updateFeedPost(requestParameters, initOverrides) {
-        const response = await this.updateFeedPostRaw(requestParameters, initOverrides);
+    async updateTenantUser(requestParameters, initOverrides) {
+        const response = await this.updateTenantUserRaw(requestParameters, initOverrides);
         return await response.value();
     }
     /**
@@ -1796,4 +3927,13 @@ class DefaultApi extends runtime.BaseAPI {
     }
 }
 exports.DefaultApi = DefaultApi;
+/**
+  * @export
+  * @enum {string}
+  */
+var CreateVoteDirectionEnum;
+(function (CreateVoteDirectionEnum) {
+    CreateVoteDirectionEnum["up"] = "up";
+    CreateVoteDirectionEnum["down"] = "down";
+})(CreateVoteDirectionEnum || (exports.CreateVoteDirectionEnum = CreateVoteDirectionEnum = {}));
 //# sourceMappingURL=DefaultApi.js.map