fastcomments_sdk/client/src/apis/

default_api.rs

/*
 * fastcomments
 *
 * No description provided (generated by Openapi Generator https://github.com/openapitools/openapi-generator)
 *
 * The version of the OpenAPI document: 0.0.0
 * 
 * Generated by: https://openapi-generator.tech
 */


use reqwest;
use serde::{Deserialize, Serialize};
use crate::client::{apis::ResponseContent, models};
use super::{Error, configuration};

/// struct for passing parameters to the method [`add_domain_config`]
#[derive(Clone, Debug)]
pub struct AddDomainConfigParams {
    pub tenant_id: String,
    pub add_domain_config_params: models::AddDomainConfigParams
}

/// struct for passing parameters to the method [`add_page`]
#[derive(Clone, Debug)]
pub struct AddPageParams {
    pub tenant_id: String,
    pub create_api_page_data: models::CreateApiPageData
}

/// struct for passing parameters to the method [`add_sso_user`]
#[derive(Clone, Debug)]
pub struct AddSsoUserParams {
    pub tenant_id: String,
    pub create_apisso_user_data: models::CreateApissoUserData
}

/// struct for passing parameters to the method [`aggregate`]
#[derive(Clone, Debug)]
pub struct AggregateParams {
    pub tenant_id: String,
    pub aggregation_request: models::AggregationRequest,
    pub parent_tenant_id: Option<String>,
    pub include_stats: Option<bool>
}

/// struct for passing parameters to the method [`aggregate_question_results`]
#[derive(Clone, Debug)]
pub struct AggregateQuestionResultsParams {
    pub tenant_id: String,
    pub question_id: Option<String>,
    pub question_ids: Option<Vec<String>>,
    pub url_id: Option<String>,
    pub time_bucket: Option<models::AggregateTimeBucket>,
    pub start_date: Option<String>,
    pub force_recalculate: Option<bool>
}

/// struct for passing parameters to the method [`block_user_from_comment`]
#[derive(Clone, Debug)]
pub struct BlockUserFromCommentParams {
    pub tenant_id: String,
    pub id: String,
    pub block_from_comment_params: models::BlockFromCommentParams,
    pub user_id: Option<String>,
    pub anon_user_id: Option<String>
}

/// struct for passing parameters to the method [`bulk_aggregate_question_results`]
#[derive(Clone, Debug)]
pub struct BulkAggregateQuestionResultsParams {
    pub tenant_id: String,
    pub bulk_aggregate_question_results_request: models::BulkAggregateQuestionResultsRequest,
    pub force_recalculate: Option<bool>
}

/// struct for passing parameters to the method [`combine_comments_with_question_results`]
#[derive(Clone, Debug)]
pub struct CombineCommentsWithQuestionResultsParams {
    pub tenant_id: String,
    pub question_id: Option<String>,
    pub question_ids: Option<Vec<String>>,
    pub url_id: Option<String>,
    pub start_date: Option<String>,
    pub force_recalculate: Option<bool>,
    pub min_value: Option<f64>,
    pub max_value: Option<f64>,
    pub limit: Option<f64>
}

/// struct for passing parameters to the method [`create_feed_post`]
#[derive(Clone, Debug)]
pub struct CreateFeedPostParams {
    pub tenant_id: String,
    pub create_feed_post_params: models::CreateFeedPostParams,
    pub broadcast_id: Option<String>,
    pub is_live: Option<bool>,
    pub do_spam_check: Option<bool>,
    pub skip_dup_check: Option<bool>
}

/// struct for passing parameters to the method [`create_subscription`]
#[derive(Clone, Debug)]
pub struct CreateSubscriptionParams {
    pub tenant_id: String,
    pub create_api_user_subscription_data: models::CreateApiUserSubscriptionData
}

/// struct for passing parameters to the method [`create_user_badge`]
#[derive(Clone, Debug)]
pub struct CreateUserBadgeParams {
    pub tenant_id: String,
    pub create_user_badge_params: models::CreateUserBadgeParams
}

/// struct for passing parameters to the method [`delete_comment`]
#[derive(Clone, Debug)]
pub struct DeleteCommentParams {
    pub tenant_id: String,
    pub id: String,
    pub context_user_id: Option<String>,
    pub is_live: Option<bool>
}

/// struct for passing parameters to the method [`delete_domain_config`]
#[derive(Clone, Debug)]
pub struct DeleteDomainConfigParams {
    pub tenant_id: String,
    pub domain: String
}

/// struct for passing parameters to the method [`delete_page`]
#[derive(Clone, Debug)]
pub struct DeletePageParams {
    pub tenant_id: String,
    pub id: String
}

/// struct for passing parameters to the method [`delete_sso_user`]
#[derive(Clone, Debug)]
pub struct DeleteSsoUserParams {
    pub tenant_id: String,
    pub id: String,
    pub delete_comments: Option<bool>,
    pub comment_delete_mode: Option<String>
}

/// struct for passing parameters to the method [`delete_subscription`]
#[derive(Clone, Debug)]
pub struct DeleteSubscriptionParams {
    pub tenant_id: String,
    pub id: String,
    pub user_id: Option<String>
}

/// struct for passing parameters to the method [`delete_user_badge`]
#[derive(Clone, Debug)]
pub struct DeleteUserBadgeParams {
    pub tenant_id: String,
    pub id: String
}

/// struct for passing parameters to the method [`flag_comment`]
#[derive(Clone, Debug)]
pub struct FlagCommentParams {
    pub tenant_id: String,
    pub id: String,
    pub user_id: Option<String>,
    pub anon_user_id: Option<String>
}

/// struct for passing parameters to the method [`get_audit_logs`]
#[derive(Clone, Debug)]
pub struct GetAuditLogsParams {
    pub tenant_id: String,
    pub limit: Option<f64>,
    pub skip: Option<f64>,
    pub order: Option<models::SortDir>,
    pub after: Option<f64>,
    pub before: Option<f64>
}

/// struct for passing parameters to the method [`get_comment`]
#[derive(Clone, Debug)]
pub struct GetCommentParams {
    pub tenant_id: String,
    pub id: String
}

/// struct for passing parameters to the method [`get_comments`]
#[derive(Clone, Debug)]
pub struct GetCommentsParams {
    pub tenant_id: String,
    pub page: Option<i32>,
    pub limit: Option<i32>,
    pub skip: Option<i32>,
    pub as_tree: Option<bool>,
    pub skip_children: Option<i32>,
    pub limit_children: Option<i32>,
    pub max_tree_depth: Option<i32>,
    pub url_id: Option<String>,
    pub user_id: Option<String>,
    pub anon_user_id: Option<String>,
    pub context_user_id: Option<String>,
    pub hash_tag: Option<String>,
    pub parent_id: Option<String>,
    pub direction: Option<models::SortDirections>
}

/// struct for passing parameters to the method [`get_domain_config`]
#[derive(Clone, Debug)]
pub struct GetDomainConfigParams {
    pub tenant_id: String,
    pub domain: String
}

/// struct for passing parameters to the method [`get_domain_configs`]
#[derive(Clone, Debug)]
pub struct GetDomainConfigsParams {
    pub tenant_id: String
}

/// struct for passing parameters to the method [`get_feed_posts`]
#[derive(Clone, Debug)]
pub struct GetFeedPostsParams {
    pub tenant_id: String,
    pub after_id: Option<String>,
    pub limit: Option<i32>,
    pub tags: Option<Vec<String>>
}

/// struct for passing parameters to the method [`get_page_by_urlid`]
#[derive(Clone, Debug)]
pub struct GetPageByUrlidParams {
    pub tenant_id: String,
    pub url_id: String
}

/// struct for passing parameters to the method [`get_pages`]
#[derive(Clone, Debug)]
pub struct GetPagesParams {
    pub tenant_id: String
}

/// struct for passing parameters to the method [`get_sso_user_by_email`]
#[derive(Clone, Debug)]
pub struct GetSsoUserByEmailParams {
    pub tenant_id: String,
    pub email: String
}

/// struct for passing parameters to the method [`get_sso_user_by_id`]
#[derive(Clone, Debug)]
pub struct GetSsoUserByIdParams {
    pub tenant_id: String,
    pub id: String
}

/// struct for passing parameters to the method [`get_sso_users`]
#[derive(Clone, Debug)]
pub struct GetSsoUsersParams {
    pub tenant_id: String,
    pub skip: Option<i32>
}

/// struct for passing parameters to the method [`get_subscriptions`]
#[derive(Clone, Debug)]
pub struct GetSubscriptionsParams {
    pub tenant_id: String,
    pub user_id: Option<String>
}

/// struct for passing parameters to the method [`get_user_badge`]
#[derive(Clone, Debug)]
pub struct GetUserBadgeParams {
    pub tenant_id: String,
    pub id: String
}

/// struct for passing parameters to the method [`get_user_badge_progress_by_id`]
#[derive(Clone, Debug)]
pub struct GetUserBadgeProgressByIdParams {
    pub tenant_id: String,
    pub id: String
}

/// struct for passing parameters to the method [`get_user_badge_progress_by_user_id`]
#[derive(Clone, Debug)]
pub struct GetUserBadgeProgressByUserIdParams {
    pub tenant_id: String,
    pub user_id: String
}

/// struct for passing parameters to the method [`get_user_badge_progress_list`]
#[derive(Clone, Debug)]
pub struct GetUserBadgeProgressListParams {
    pub tenant_id: String,
    pub user_id: Option<String>,
    pub limit: Option<f64>,
    pub skip: Option<f64>
}

/// struct for passing parameters to the method [`get_user_badges`]
#[derive(Clone, Debug)]
pub struct GetUserBadgesParams {
    pub tenant_id: String,
    pub user_id: Option<String>,
    pub badge_id: Option<String>,
    pub r#type: Option<f64>,
    pub displayed_on_comments: Option<bool>,
    pub limit: Option<f64>,
    pub skip: Option<f64>
}

/// struct for passing parameters to the method [`patch_domain_config`]
#[derive(Clone, Debug)]
pub struct PatchDomainConfigParams {
    pub tenant_id: String,
    pub domain_to_update: String,
    pub patch_domain_config_params: models::PatchDomainConfigParams
}

/// struct for passing parameters to the method [`patch_page`]
#[derive(Clone, Debug)]
pub struct PatchPageParams {
    pub tenant_id: String,
    pub id: String,
    pub update_api_page_data: models::UpdateApiPageData
}

/// struct for passing parameters to the method [`patch_sso_user`]
#[derive(Clone, Debug)]
pub struct PatchSsoUserParams {
    pub tenant_id: String,
    pub id: String,
    pub update_apisso_user_data: models::UpdateApissoUserData,
    pub update_comments: Option<bool>
}

/// struct for passing parameters to the method [`put_domain_config`]
#[derive(Clone, Debug)]
pub struct PutDomainConfigParams {
    pub tenant_id: String,
    pub domain_to_update: String,
    pub update_domain_config_params: models::UpdateDomainConfigParams
}

/// struct for passing parameters to the method [`put_sso_user`]
#[derive(Clone, Debug)]
pub struct PutSsoUserParams {
    pub tenant_id: String,
    pub id: String,
    pub update_apisso_user_data: models::UpdateApissoUserData,
    pub update_comments: Option<bool>
}

/// struct for passing parameters to the method [`save_comment`]
#[derive(Clone, Debug)]
pub struct SaveCommentParams {
    pub tenant_id: String,
    pub create_comment_params: models::CreateCommentParams,
    pub is_live: Option<bool>,
    pub do_spam_check: Option<bool>,
    pub send_emails: Option<bool>,
    pub populate_notifications: Option<bool>
}

/// struct for passing parameters to the method [`save_comments_bulk`]
#[derive(Clone, Debug)]
pub struct SaveCommentsBulkParams {
    pub tenant_id: String,
    pub create_comment_params: Vec<models::CreateCommentParams>,
    pub is_live: Option<bool>,
    pub do_spam_check: Option<bool>,
    pub send_emails: Option<bool>,
    pub populate_notifications: Option<bool>
}

/// struct for passing parameters to the method [`un_block_user_from_comment`]
#[derive(Clone, Debug)]
pub struct UnBlockUserFromCommentParams {
    pub tenant_id: String,
    pub id: String,
    pub un_block_from_comment_params: models::UnBlockFromCommentParams,
    pub user_id: Option<String>,
    pub anon_user_id: Option<String>
}

/// struct for passing parameters to the method [`un_flag_comment`]
#[derive(Clone, Debug)]
pub struct UnFlagCommentParams {
    pub tenant_id: String,
    pub id: String,
    pub user_id: Option<String>,
    pub anon_user_id: Option<String>
}

/// struct for passing parameters to the method [`update_comment`]
#[derive(Clone, Debug)]
pub struct UpdateCommentParams {
    pub tenant_id: String,
    pub id: String,
    pub body: models::PickApiCommentPeriodUpdatableCommentFields,
    pub context_user_id: Option<String>,
    pub do_spam_check: Option<bool>,
    pub is_live: Option<bool>
}

/// struct for passing parameters to the method [`update_feed_post`]
#[derive(Clone, Debug)]
pub struct UpdateFeedPostParams {
    pub tenant_id: String,
    pub id: String,
    pub feed_post: models::FeedPost
}

/// struct for passing parameters to the method [`update_user_badge`]
#[derive(Clone, Debug)]
pub struct UpdateUserBadgeParams {
    pub tenant_id: String,
    pub id: String,
    pub update_user_badge_params: models::UpdateUserBadgeParams
}


/// struct for typed errors of method [`add_domain_config`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AddDomainConfigError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`add_page`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AddPageError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`add_sso_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AddSsoUserError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`aggregate`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AggregateError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`aggregate_question_results`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AggregateQuestionResultsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`block_user_from_comment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BlockUserFromCommentError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`bulk_aggregate_question_results`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum BulkAggregateQuestionResultsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`combine_comments_with_question_results`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CombineCommentsWithQuestionResultsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_feed_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateFeedPostError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_subscription`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateSubscriptionError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_user_badge`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateUserBadgeError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_comment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteCommentError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_domain_config`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteDomainConfigError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_page`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeletePageError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_sso_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteSsoUserError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_subscription`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteSubscriptionError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_user_badge`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteUserBadgeError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`flag_comment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FlagCommentError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_audit_logs`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAuditLogsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_comment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCommentError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_comments`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCommentsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_domain_config`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetDomainConfigError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_domain_configs`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetDomainConfigsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_feed_posts`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetFeedPostsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_page_by_urlid`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetPageByUrlidError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_pages`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetPagesError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_sso_user_by_email`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSsoUserByEmailError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_sso_user_by_id`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSsoUserByIdError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_sso_users`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSsoUsersError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_subscriptions`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetSubscriptionsError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_user_badge`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetUserBadgeError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_user_badge_progress_by_id`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetUserBadgeProgressByIdError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_user_badge_progress_by_user_id`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetUserBadgeProgressByUserIdError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_user_badge_progress_list`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetUserBadgeProgressListError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_user_badges`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetUserBadgesError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_domain_config`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchDomainConfigError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_page`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchPageError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_sso_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchSsoUserError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`put_domain_config`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PutDomainConfigError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`put_sso_user`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PutSsoUserError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`save_comment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SaveCommentError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`save_comments_bulk`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SaveCommentsBulkError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`un_block_user_from_comment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UnBlockUserFromCommentError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`un_flag_comment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UnFlagCommentError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`update_comment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateCommentError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`update_feed_post`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateFeedPostError {
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`update_user_badge`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateUserBadgeError {
    UnknownValue(serde_json::Value),
}


pub async fn add_domain_config(configuration: &configuration::Configuration, params: AddDomainConfigParams) -> Result<models::AddDomainConfig200Response, Error<AddDomainConfigError>> {

    let uri_str = format!("{}/api/v1/domain-configs", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.add_domain_config_params);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<AddDomainConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn add_page(configuration: &configuration::Configuration, params: AddPageParams) -> Result<models::AddPageApiResponse, Error<AddPageError>> {

    let uri_str = format!("{}/api/v1/pages", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.create_api_page_data);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<AddPageError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn add_sso_user(configuration: &configuration::Configuration, params: AddSsoUserParams) -> Result<models::AddSsoUserApiResponse, Error<AddSsoUserError>> {

    let uri_str = format!("{}/api/v1/sso-users", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.create_apisso_user_data);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<AddSsoUserError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Aggregates documents by grouping them (if groupBy is provided) and applying multiple operations. Different operations (e.g. sum, countDistinct, avg, etc.) are supported.
pub async fn aggregate(configuration: &configuration::Configuration, params: AggregateParams) -> Result<models::AggregationResponse, Error<AggregateError>> {

    let uri_str = format!("{}/api/v1/aggregate", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.parent_tenant_id {
        req_builder = req_builder.query(&[("parentTenantId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.include_stats {
        req_builder = req_builder.query(&[("includeStats", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.aggregation_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<AggregateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn aggregate_question_results(configuration: &configuration::Configuration, params: AggregateQuestionResultsParams) -> Result<models::AggregateQuestionResults200Response, Error<AggregateQuestionResultsError>> {

    let uri_str = format!("{}/api/v1/question-results-aggregation", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.question_id {
        req_builder = req_builder.query(&[("questionId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.question_ids {
        req_builder = match "multi" {
            "multi" => req_builder.query(&param_value.into_iter().map(|p| ("questionIds".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
            _ => req_builder.query(&[("questionIds", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
        };
    }
    if let Some(ref param_value) = params.url_id {
        req_builder = req_builder.query(&[("urlId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.time_bucket {
        req_builder = req_builder.query(&[("timeBucket", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.start_date {
        req_builder = req_builder.query(&[("startDate", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.force_recalculate {
        req_builder = req_builder.query(&[("forceRecalculate", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<AggregateQuestionResultsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn block_user_from_comment(configuration: &configuration::Configuration, params: BlockUserFromCommentParams) -> Result<models::BlockFromCommentPublic200Response, Error<BlockUserFromCommentError>> {

    let uri_str = format!("{}/api/v1/comments/{id}/block", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.user_id {
        req_builder = req_builder.query(&[("userId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.anon_user_id {
        req_builder = req_builder.query(&[("anonUserId", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.block_from_comment_params);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<BlockUserFromCommentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn bulk_aggregate_question_results(configuration: &configuration::Configuration, params: BulkAggregateQuestionResultsParams) -> Result<models::BulkAggregateQuestionResults200Response, Error<BulkAggregateQuestionResultsError>> {

    let uri_str = format!("{}/api/v1/question-results-aggregation/bulk", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.force_recalculate {
        req_builder = req_builder.query(&[("forceRecalculate", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.bulk_aggregate_question_results_request);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<BulkAggregateQuestionResultsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn combine_comments_with_question_results(configuration: &configuration::Configuration, params: CombineCommentsWithQuestionResultsParams) -> Result<models::CombineCommentsWithQuestionResults200Response, Error<CombineCommentsWithQuestionResultsError>> {

    let uri_str = format!("{}/api/v1/question-results-aggregation/combine/comments", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.question_id {
        req_builder = req_builder.query(&[("questionId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.question_ids {
        req_builder = match "multi" {
            "multi" => req_builder.query(&param_value.into_iter().map(|p| ("questionIds".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
            _ => req_builder.query(&[("questionIds", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
        };
    }
    if let Some(ref param_value) = params.url_id {
        req_builder = req_builder.query(&[("urlId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.start_date {
        req_builder = req_builder.query(&[("startDate", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.force_recalculate {
        req_builder = req_builder.query(&[("forceRecalculate", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.min_value {
        req_builder = req_builder.query(&[("minValue", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.max_value {
        req_builder = req_builder.query(&[("maxValue", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<CombineCommentsWithQuestionResultsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_feed_post(configuration: &configuration::Configuration, params: CreateFeedPostParams) -> Result<models::CreateFeedPost200Response, Error<CreateFeedPostError>> {

    let uri_str = format!("{}/api/v1/feed-posts", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.broadcast_id {
        req_builder = req_builder.query(&[("broadcastId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.is_live {
        req_builder = req_builder.query(&[("isLive", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.do_spam_check {
        req_builder = req_builder.query(&[("doSpamCheck", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.skip_dup_check {
        req_builder = req_builder.query(&[("skipDupCheck", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.create_feed_post_params);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateFeedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_subscription(configuration: &configuration::Configuration, params: CreateSubscriptionParams) -> Result<models::CreateSubscriptionApiResponse, Error<CreateSubscriptionError>> {

    let uri_str = format!("{}/api/v1/subscriptions", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.create_api_user_subscription_data);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateSubscriptionError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_user_badge(configuration: &configuration::Configuration, params: CreateUserBadgeParams) -> Result<models::CreateUserBadge200Response, Error<CreateUserBadgeError>> {

    let uri_str = format!("{}/api/v1/user-badges", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.create_user_badge_params);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateUserBadgeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_comment(configuration: &configuration::Configuration, params: DeleteCommentParams) -> Result<models::DeleteComment200Response, Error<DeleteCommentError>> {

    let uri_str = format!("{}/api/v1/comments/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.context_user_id {
        req_builder = req_builder.query(&[("contextUserId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.is_live {
        req_builder = req_builder.query(&[("isLive", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteCommentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_domain_config(configuration: &configuration::Configuration, params: DeleteDomainConfigParams) -> Result<models::DeleteDomainConfig200Response, Error<DeleteDomainConfigError>> {

    let uri_str = format!("{}/api/v1/domain-configs/{domain}", configuration.base_path, domain=crate::client::apis::urlencode(params.domain));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteDomainConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_page(configuration: &configuration::Configuration, params: DeletePageParams) -> Result<models::DeletePageApiResponse, Error<DeletePageError>> {

    let uri_str = format!("{}/api/v1/pages/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<DeletePageError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_sso_user(configuration: &configuration::Configuration, params: DeleteSsoUserParams) -> Result<models::DeleteSsoUserApiResponse, Error<DeleteSsoUserError>> {

    let uri_str = format!("{}/api/v1/sso-users/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.delete_comments {
        req_builder = req_builder.query(&[("deleteComments", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.comment_delete_mode {
        req_builder = req_builder.query(&[("commentDeleteMode", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteSsoUserError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_subscription(configuration: &configuration::Configuration, params: DeleteSubscriptionParams) -> Result<models::DeleteSubscriptionApiResponse, Error<DeleteSubscriptionError>> {

    let uri_str = format!("{}/api/v1/subscriptions/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.user_id {
        req_builder = req_builder.query(&[("userId", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteSubscriptionError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_user_badge(configuration: &configuration::Configuration, params: DeleteUserBadgeParams) -> Result<models::UpdateUserBadge200Response, Error<DeleteUserBadgeError>> {

    let uri_str = format!("{}/api/v1/user-badges/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteUserBadgeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn flag_comment(configuration: &configuration::Configuration, params: FlagCommentParams) -> Result<models::FlagComment200Response, Error<FlagCommentError>> {

    let uri_str = format!("{}/api/v1/comments/{id}/flag", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.user_id {
        req_builder = req_builder.query(&[("userId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.anon_user_id {
        req_builder = req_builder.query(&[("anonUserId", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<FlagCommentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_audit_logs(configuration: &configuration::Configuration, params: GetAuditLogsParams) -> Result<models::GetAuditLogs200Response, Error<GetAuditLogsError>> {

    let uri_str = format!("{}/api/v1/audit-logs", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.skip {
        req_builder = req_builder.query(&[("skip", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.order {
        req_builder = req_builder.query(&[("order", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.after {
        req_builder = req_builder.query(&[("after", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.before {
        req_builder = req_builder.query(&[("before", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAuditLogsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_comment(configuration: &configuration::Configuration, params: GetCommentParams) -> Result<models::GetComment200Response, Error<GetCommentError>> {

    let uri_str = format!("{}/api/v1/comments/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCommentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_comments(configuration: &configuration::Configuration, params: GetCommentsParams) -> Result<models::GetComments200Response, Error<GetCommentsError>> {

    let uri_str = format!("{}/api/v1/comments", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.page {
        req_builder = req_builder.query(&[("page", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.skip {
        req_builder = req_builder.query(&[("skip", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.as_tree {
        req_builder = req_builder.query(&[("asTree", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.skip_children {
        req_builder = req_builder.query(&[("skipChildren", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.limit_children {
        req_builder = req_builder.query(&[("limitChildren", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.max_tree_depth {
        req_builder = req_builder.query(&[("maxTreeDepth", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.url_id {
        req_builder = req_builder.query(&[("urlId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.user_id {
        req_builder = req_builder.query(&[("userId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.anon_user_id {
        req_builder = req_builder.query(&[("anonUserId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.context_user_id {
        req_builder = req_builder.query(&[("contextUserId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.hash_tag {
        req_builder = req_builder.query(&[("hashTag", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.parent_id {
        req_builder = req_builder.query(&[("parentId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.direction {
        req_builder = req_builder.query(&[("direction", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCommentsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_domain_config(configuration: &configuration::Configuration, params: GetDomainConfigParams) -> Result<models::GetDomainConfig200Response, Error<GetDomainConfigError>> {

    let uri_str = format!("{}/api/v1/domain-configs/{domain}", configuration.base_path, domain=crate::client::apis::urlencode(params.domain));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetDomainConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_domain_configs(configuration: &configuration::Configuration, params: GetDomainConfigsParams) -> Result<models::GetDomainConfigs200Response, Error<GetDomainConfigsError>> {

    let uri_str = format!("{}/api/v1/domain-configs", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetDomainConfigsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

///  req tenantId afterId
pub async fn get_feed_posts(configuration: &configuration::Configuration, params: GetFeedPostsParams) -> Result<models::GetFeedPosts200Response, Error<GetFeedPostsError>> {

    let uri_str = format!("{}/api/v1/feed-posts", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.after_id {
        req_builder = req_builder.query(&[("afterId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.tags {
        req_builder = match "multi" {
            "multi" => req_builder.query(&param_value.into_iter().map(|p| ("tags".to_owned(), p.to_string())).collect::<Vec<(std::string::String, std::string::String)>>()),
            _ => req_builder.query(&[("tags", &param_value.into_iter().map(|p| p.to_string()).collect::<Vec<String>>().join(",").to_string())]),
        };
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetFeedPostsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_page_by_urlid(configuration: &configuration::Configuration, params: GetPageByUrlidParams) -> Result<models::GetPageByUrlidApiResponse, Error<GetPageByUrlidError>> {

    let uri_str = format!("{}/api/v1/pages/by-url-id", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    req_builder = req_builder.query(&[("urlId", &params.url_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetPageByUrlidError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_pages(configuration: &configuration::Configuration, params: GetPagesParams) -> Result<models::GetPagesApiResponse, Error<GetPagesError>> {

    let uri_str = format!("{}/api/v1/pages", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetPagesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_sso_user_by_email(configuration: &configuration::Configuration, params: GetSsoUserByEmailParams) -> Result<models::GetSsoUserByEmailApiResponse, Error<GetSsoUserByEmailError>> {

    let uri_str = format!("{}/api/v1/sso-users/by-email/{email}", configuration.base_path, email=crate::client::apis::urlencode(params.email));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSsoUserByEmailError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_sso_user_by_id(configuration: &configuration::Configuration, params: GetSsoUserByIdParams) -> Result<models::GetSsoUserByIdApiResponse, Error<GetSsoUserByIdError>> {

    let uri_str = format!("{}/api/v1/sso-users/by-id/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSsoUserByIdError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_sso_users(configuration: &configuration::Configuration, params: GetSsoUsersParams) -> Result<models::GetSsoUsers200Response, Error<GetSsoUsersError>> {

    let uri_str = format!("{}/api/v1/sso-users", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.skip {
        req_builder = req_builder.query(&[("skip", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSsoUsersError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_subscriptions(configuration: &configuration::Configuration, params: GetSubscriptionsParams) -> Result<models::GetSubscriptionsApiResponse, Error<GetSubscriptionsError>> {

    let uri_str = format!("{}/api/v1/subscriptions", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.user_id {
        req_builder = req_builder.query(&[("userId", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSubscriptionsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_user_badge(configuration: &configuration::Configuration, params: GetUserBadgeParams) -> Result<models::GetUserBadge200Response, Error<GetUserBadgeError>> {

    let uri_str = format!("{}/api/v1/user-badges/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetUserBadgeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_user_badge_progress_by_id(configuration: &configuration::Configuration, params: GetUserBadgeProgressByIdParams) -> Result<models::GetUserBadgeProgressById200Response, Error<GetUserBadgeProgressByIdError>> {

    let uri_str = format!("{}/api/v1/user-badge-progress/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetUserBadgeProgressByIdError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_user_badge_progress_by_user_id(configuration: &configuration::Configuration, params: GetUserBadgeProgressByUserIdParams) -> Result<models::GetUserBadgeProgressById200Response, Error<GetUserBadgeProgressByUserIdError>> {

    let uri_str = format!("{}/api/v1/user-badge-progress/user/{userId}", configuration.base_path, userId=crate::client::apis::urlencode(params.user_id));
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetUserBadgeProgressByUserIdError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_user_badge_progress_list(configuration: &configuration::Configuration, params: GetUserBadgeProgressListParams) -> Result<models::GetUserBadgeProgressList200Response, Error<GetUserBadgeProgressListError>> {

    let uri_str = format!("{}/api/v1/user-badge-progress", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.user_id {
        req_builder = req_builder.query(&[("userId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.skip {
        req_builder = req_builder.query(&[("skip", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetUserBadgeProgressListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_user_badges(configuration: &configuration::Configuration, params: GetUserBadgesParams) -> Result<models::GetUserBadges200Response, Error<GetUserBadgesError>> {

    let uri_str = format!("{}/api/v1/user-badges", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.user_id {
        req_builder = req_builder.query(&[("userId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.badge_id {
        req_builder = req_builder.query(&[("badgeId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.r#type {
        req_builder = req_builder.query(&[("type", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.displayed_on_comments {
        req_builder = req_builder.query(&[("displayedOnComments", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.skip {
        req_builder = req_builder.query(&[("skip", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<GetUserBadgesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn patch_domain_config(configuration: &configuration::Configuration, params: PatchDomainConfigParams) -> Result<models::GetDomainConfig200Response, Error<PatchDomainConfigError>> {

    let uri_str = format!("{}/api/v1/domain-configs/{domainToUpdate}", configuration.base_path, domainToUpdate=crate::client::apis::urlencode(params.domain_to_update));
    let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.patch_domain_config_params);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<PatchDomainConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn patch_page(configuration: &configuration::Configuration, params: PatchPageParams) -> Result<models::PatchPageApiResponse, Error<PatchPageError>> {

    let uri_str = format!("{}/api/v1/pages/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.update_api_page_data);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<PatchPageError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn patch_sso_user(configuration: &configuration::Configuration, params: PatchSsoUserParams) -> Result<models::PatchSsoUserApiResponse, Error<PatchSsoUserError>> {

    let uri_str = format!("{}/api/v1/sso-users/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.update_comments {
        req_builder = req_builder.query(&[("updateComments", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.update_apisso_user_data);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<PatchSsoUserError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn put_domain_config(configuration: &configuration::Configuration, params: PutDomainConfigParams) -> Result<models::GetDomainConfig200Response, Error<PutDomainConfigError>> {

    let uri_str = format!("{}/api/v1/domain-configs/{domainToUpdate}", configuration.base_path, domainToUpdate=crate::client::apis::urlencode(params.domain_to_update));
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.update_domain_config_params);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<PutDomainConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn put_sso_user(configuration: &configuration::Configuration, params: PutSsoUserParams) -> Result<models::PutSsoUserApiResponse, Error<PutSsoUserError>> {

    let uri_str = format!("{}/api/v1/sso-users/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.update_comments {
        req_builder = req_builder.query(&[("updateComments", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.update_apisso_user_data);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<PutSsoUserError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn save_comment(configuration: &configuration::Configuration, params: SaveCommentParams) -> Result<models::SaveComment200Response, Error<SaveCommentError>> {

    let uri_str = format!("{}/api/v1/comments", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.is_live {
        req_builder = req_builder.query(&[("isLive", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.do_spam_check {
        req_builder = req_builder.query(&[("doSpamCheck", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.send_emails {
        req_builder = req_builder.query(&[("sendEmails", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.populate_notifications {
        req_builder = req_builder.query(&[("populateNotifications", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.create_comment_params);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<SaveCommentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn save_comments_bulk(configuration: &configuration::Configuration, params: SaveCommentsBulkParams) -> Result<Vec<models::SaveComment200Response>, Error<SaveCommentsBulkError>> {

    let uri_str = format!("{}/api/v1/comments/bulk", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.is_live {
        req_builder = req_builder.query(&[("isLive", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.do_spam_check {
        req_builder = req_builder.query(&[("doSpamCheck", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.send_emails {
        req_builder = req_builder.query(&[("sendEmails", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.populate_notifications {
        req_builder = req_builder.query(&[("populateNotifications", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.create_comment_params);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<SaveCommentsBulkError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn un_block_user_from_comment(configuration: &configuration::Configuration, params: UnBlockUserFromCommentParams) -> Result<models::UnBlockCommentPublic200Response, Error<UnBlockUserFromCommentError>> {

    let uri_str = format!("{}/api/v1/comments/{id}/un-block", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.user_id {
        req_builder = req_builder.query(&[("userId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.anon_user_id {
        req_builder = req_builder.query(&[("anonUserId", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.un_block_from_comment_params);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<UnBlockUserFromCommentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn un_flag_comment(configuration: &configuration::Configuration, params: UnFlagCommentParams) -> Result<models::FlagComment200Response, Error<UnFlagCommentError>> {

    let uri_str = format!("{}/api/v1/comments/{id}/un-flag", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.user_id {
        req_builder = req_builder.query(&[("userId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.anon_user_id {
        req_builder = req_builder.query(&[("anonUserId", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<UnFlagCommentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_comment(configuration: &configuration::Configuration, params: UpdateCommentParams) -> Result<models::FlagCommentPublic200Response, Error<UpdateCommentError>> {

    let uri_str = format!("{}/api/v1/comments/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref param_value) = params.context_user_id {
        req_builder = req_builder.query(&[("contextUserId", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.do_spam_check {
        req_builder = req_builder.query(&[("doSpamCheck", &param_value.to_string())]);
    }
    if let Some(ref param_value) = params.is_live {
        req_builder = req_builder.query(&[("isLive", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.body);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateCommentError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_feed_post(configuration: &configuration::Configuration, params: UpdateFeedPostParams) -> Result<models::FlagCommentPublic200Response, Error<UpdateFeedPostError>> {

    let uri_str = format!("{}/api/v1/feed-posts/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::PATCH, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.feed_post);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateFeedPostError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_user_badge(configuration: &configuration::Configuration, params: UpdateUserBadgeParams) -> Result<models::UpdateUserBadge200Response, Error<UpdateUserBadgeError>> {

    let uri_str = format!("{}/api/v1/user-badges/{id}", configuration.base_path, id=crate::client::apis::urlencode(params.id));
    let mut req_builder = configuration.client.request(reqwest::Method::PUT, &uri_str);

    req_builder = req_builder.query(&[("tenantId", &params.tenant_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref apikey) = configuration.api_key {
        let key = apikey.key.clone();
        let value = match apikey.prefix {
            Some(ref prefix) => format!("{} {}", prefix, key),
            None => key,
        };
        req_builder = req_builder.header("x-api-key", value);
    };
    req_builder = req_builder.json(&params.update_user_badge_params);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        serde_json::from_str(&content).map_err(Error::from)
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateUserBadgeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}