akeyless_api/apis/

v2_api.rs

/*
 * Akeyless API
 *
 * The purpose of this application is to provide access to Akeyless API.
 *
 * The version of the OpenAPI document: 3.0
 * Contact: support@akeyless.io
 * Generated by: https://openapi-generator.tech
 */


use reqwest;
use serde::{Deserialize, Serialize, de::Error as _};
use crate::{apis::ResponseContent, models};
use super::{Error, configuration, ContentType};


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

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

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

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

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

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

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

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

/// struct for typed errors of method [`auth`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum AuthError {
    Status401(models::JsonError),
    DefaultResponse(models::JsonError),
    UnknownValue(serde_json::Value),
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// struct for typed errors of method [`describe_sub_claims`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DescribeSubClaimsError {
    Status401(models::JsonError),
    DefaultResponse(models::JsonError),
    UnknownValue(serde_json::Value),
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// struct for typed errors of method [`get_cert_challenge`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCertChallengeError {
    Status400(models::JsonError),
    DefaultResponse(models::JsonError),
    UnknownValue(serde_json::Value),
}

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

/// struct for typed errors of method [`validate_token`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ValidateTokenError {
    Status401(models::JsonError),
    DefaultResponse(models::JsonError),
    UnknownValue(serde_json::Value),
}

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

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

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

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

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

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

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

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


pub async fn account_custom_field_create(configuration: &configuration::Configuration, account_custom_field_create: models::AccountCustomFieldCreate) -> Result<models::AccountCustomFieldCreateOutput, Error<AccountCustomFieldCreateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_account_custom_field_create = account_custom_field_create;

    let uri_str = format!("{}/account-custom-field-create", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_account_custom_field_create);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccountCustomFieldCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AccountCustomFieldCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AccountCustomFieldCreateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn account_custom_field_delete(configuration: &configuration::Configuration, account_custom_field_delete: models::AccountCustomFieldDelete) -> Result<serde_json::Value, Error<AccountCustomFieldDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_account_custom_field_delete = account_custom_field_delete;

    let uri_str = format!("{}/account-custom-field-delete", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_account_custom_field_delete);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AccountCustomFieldDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn account_custom_field_get(configuration: &configuration::Configuration, account_custom_field_get: models::AccountCustomFieldGet) -> Result<models::AccountCustomFieldGetOutput, Error<AccountCustomFieldGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_account_custom_field_get = account_custom_field_get;

    let uri_str = format!("{}/account-custom-field-get", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_account_custom_field_get);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AccountCustomFieldGetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AccountCustomFieldGetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AccountCustomFieldGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

/// Returns a list of all custom fields configured for the account, optionally filtered by object and object type.
pub async fn account_custom_field_list(configuration: &configuration::Configuration, account_custom_field_list: models::AccountCustomFieldList) -> Result<serde_json::Value, Error<AccountCustomFieldListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_account_custom_field_list = account_custom_field_list;

    let uri_str = format!("{}/account-custom-field-list", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_account_custom_field_list);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AccountCustomFieldListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn account_custom_field_update(configuration: &configuration::Configuration, account_custom_field_update: models::AccountCustomFieldUpdate) -> Result<serde_json::Value, Error<AccountCustomFieldUpdateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_account_custom_field_update = account_custom_field_update;

    let uri_str = format!("{}/account-custom-field-update", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_account_custom_field_update);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AccountCustomFieldUpdateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn alias_details(configuration: &configuration::Configuration, alias_details: models::AliasDetails) -> Result<serde_json::Value, Error<AliasDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_alias_details = alias_details;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_alias_details);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AliasDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn assoc_role_auth_method(configuration: &configuration::Configuration, assoc_role_auth_method: models::AssocRoleAuthMethod) -> Result<models::CreateRoleAuthMethodAssocOutput, Error<AssocRoleAuthMethodError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_assoc_role_auth_method = assoc_role_auth_method;

    let uri_str = format!("{}/assoc-role-am", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_assoc_role_auth_method);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateRoleAuthMethodAssocOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateRoleAuthMethodAssocOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AssocRoleAuthMethodError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn assoc_target_item(configuration: &configuration::Configuration, assoc_target_item: models::AssocTargetItem) -> Result<models::CreateTargetItemAssocOutput, Error<AssocTargetItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_assoc_target_item = assoc_target_item;

    let uri_str = format!("{}/assoc-target-item", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_assoc_target_item);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTargetItemAssocOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTargetItemAssocOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AssocTargetItemError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth(configuration: &configuration::Configuration, auth: models::Auth) -> Result<models::AuthOutput, Error<AuthError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth = auth;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_api_key(configuration: &configuration::Configuration, auth_method_create_api_key: models::AuthMethodCreateApiKey) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateApiKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_api_key = auth_method_create_api_key;

    let uri_str = format!("{}/auth-method-create-api-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_api_key);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateApiKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_aws_iam(configuration: &configuration::Configuration, auth_method_create_aws_iam: models::AuthMethodCreateAwsIam) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateAwsIamError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_aws_iam = auth_method_create_aws_iam;

    let uri_str = format!("{}/auth-method-create-aws-iam", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_aws_iam);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateAwsIamError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_azure_ad(configuration: &configuration::Configuration, auth_method_create_azure_ad: models::AuthMethodCreateAzureAd) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateAzureAdError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_azure_ad = auth_method_create_azure_ad;

    let uri_str = format!("{}/auth-method-create-azure-ad", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_azure_ad);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateAzureAdError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_cert(configuration: &configuration::Configuration, auth_method_create_cert: models::AuthMethodCreateCert) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateCertError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_cert = auth_method_create_cert;

    let uri_str = format!("{}/auth-method-create-cert", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_cert);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateCertError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_email(configuration: &configuration::Configuration, auth_method_create_email: models::AuthMethodCreateEmail) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateEmailError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_email = auth_method_create_email;

    let uri_str = format!("{}/auth-method-create-email", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_email);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateEmailError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_gcp(configuration: &configuration::Configuration, auth_method_create_gcp: models::AuthMethodCreateGcp) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_gcp = auth_method_create_gcp;

    let uri_str = format!("{}/auth-method-create-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_gcp);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_k8s(configuration: &configuration::Configuration, auth_method_create_k8s: models::AuthMethodCreateK8s) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateK8sError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_k8s = auth_method_create_k8s;

    let uri_str = format!("{}/auth-method-create-k8s", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_k8s);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateK8sError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_kerberos(configuration: &configuration::Configuration, auth_method_create_kerberos: models::AuthMethodCreateKerberos) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateKerberosError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_kerberos = auth_method_create_kerberos;

    let uri_str = format!("{}/auth-method-create-kerberos", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_kerberos);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateKerberosError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_ldap(configuration: &configuration::Configuration, auth_method_create_ldap: models::AuthMethodCreateLdap) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_ldap = auth_method_create_ldap;

    let uri_str = format!("{}/auth-method-create-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_ldap);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_oauth2(configuration: &configuration::Configuration, auth_method_create_oauth2: models::AuthMethodCreateOauth2) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateOauth2Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_oauth2 = auth_method_create_oauth2;

    let uri_str = format!("{}/auth-method-create-oauth2", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_oauth2);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateOauth2Error> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_oci(configuration: &configuration::Configuration, auth_method_create_oci: models::AuthMethodCreateOci) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateOciError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_oci = auth_method_create_oci;

    let uri_str = format!("{}/auth-method-create-oci", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_oci);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateOciError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_oidc(configuration: &configuration::Configuration, auth_method_create_oidc: models::AuthMethodCreateOidc) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateOidcError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_oidc = auth_method_create_oidc;

    let uri_str = format!("{}/auth-method-create-oidc", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_oidc);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateOidcError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_saml(configuration: &configuration::Configuration, auth_method_create_saml: models::AuthMethodCreateSaml) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateSamlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_saml = auth_method_create_saml;

    let uri_str = format!("{}/auth-method-create-saml", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_saml);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateSamlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_create_universal_identity(configuration: &configuration::Configuration, auth_method_create_universal_identity: models::AuthMethodCreateUniversalIdentity) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodCreateUniversalIdentityError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_create_universal_identity = auth_method_create_universal_identity;

    let uri_str = format!("{}/auth-method-create-universal-identity", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_create_universal_identity);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodCreateUniversalIdentityError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_delete(configuration: &configuration::Configuration, auth_method_delete: models::AuthMethodDelete) -> Result<models::AuthMethodDeleteOutput, Error<AuthMethodDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_delete = auth_method_delete;

    let uri_str = format!("{}/auth-method-delete", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_delete);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodDeleteOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodDeleteOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_get(configuration: &configuration::Configuration, auth_method_get: models::AuthMethodGet) -> Result<models::AuthMethod, Error<AuthMethodGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_get = auth_method_get;

    let uri_str = format!("{}/auth-method-get", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_get);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethod`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethod`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_list(configuration: &configuration::Configuration, auth_method_list: models::AuthMethodList) -> Result<models::ListAuthMethodsOutput, Error<AuthMethodListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_list = auth_method_list;

    let uri_str = format!("{}/auth-method-list", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_list);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListAuthMethodsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListAuthMethodsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_api_key(configuration: &configuration::Configuration, auth_method_update_api_key: models::AuthMethodUpdateApiKey) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateApiKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_api_key = auth_method_update_api_key;

    let uri_str = format!("{}/auth-method-update-api-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_api_key);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateApiKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_aws_iam(configuration: &configuration::Configuration, auth_method_update_aws_iam: models::AuthMethodUpdateAwsIam) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateAwsIamError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_aws_iam = auth_method_update_aws_iam;

    let uri_str = format!("{}/auth-method-update-aws-iam", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_aws_iam);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateAwsIamError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_azure_ad(configuration: &configuration::Configuration, auth_method_update_azure_ad: models::AuthMethodUpdateAzureAd) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateAzureAdError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_azure_ad = auth_method_update_azure_ad;

    let uri_str = format!("{}/auth-method-update-azure-ad", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_azure_ad);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateAzureAdError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_cert(configuration: &configuration::Configuration, auth_method_update_cert: models::AuthMethodUpdateCert) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateCertError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_cert = auth_method_update_cert;

    let uri_str = format!("{}/auth-method-update-cert", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_cert);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateCertError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_email(configuration: &configuration::Configuration, auth_method_update_email: models::AuthMethodUpdateEmail) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateEmailError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_email = auth_method_update_email;

    let uri_str = format!("{}/auth-method-update-email", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_email);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateEmailError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_gcp(configuration: &configuration::Configuration, auth_method_update_gcp: models::AuthMethodUpdateGcp) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_gcp = auth_method_update_gcp;

    let uri_str = format!("{}/auth-method-update-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_gcp);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_k8s(configuration: &configuration::Configuration, auth_method_update_k8s: models::AuthMethodUpdateK8s) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateK8sError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_k8s = auth_method_update_k8s;

    let uri_str = format!("{}/auth-method-update-k8s", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_k8s);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateK8sError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_kerberos(configuration: &configuration::Configuration, auth_method_update_kerberos: models::AuthMethodUpdateKerberos) -> Result<models::AuthMethodCreateOutput, Error<AuthMethodUpdateKerberosError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_kerberos = auth_method_update_kerberos;

    let uri_str = format!("{}/auth-method-update-kerberos", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_kerberos);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateKerberosError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_ldap(configuration: &configuration::Configuration, auth_method_update_ldap: models::AuthMethodUpdateLdap) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_ldap = auth_method_update_ldap;

    let uri_str = format!("{}/auth-method-update-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_ldap);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_oauth2(configuration: &configuration::Configuration, auth_method_update_oauth2: models::AuthMethodUpdateOauth2) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateOauth2Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_oauth2 = auth_method_update_oauth2;

    let uri_str = format!("{}/auth-method-update-oauth2", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_oauth2);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateOauth2Error> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_oci(configuration: &configuration::Configuration, auth_method_update_oci: models::AuthMethodUpdateOci) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateOciError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_oci = auth_method_update_oci;

    let uri_str = format!("{}/auth-method-update-oci", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_oci);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateOciError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_oidc(configuration: &configuration::Configuration, auth_method_update_oidc: models::AuthMethodUpdateOidc) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateOidcError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_oidc = auth_method_update_oidc;

    let uri_str = format!("{}/auth-method-update-oidc", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_oidc);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateOidcError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_saml(configuration: &configuration::Configuration, auth_method_update_saml: models::AuthMethodUpdateSaml) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateSamlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_saml = auth_method_update_saml;

    let uri_str = format!("{}/auth-method-update-saml", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_saml);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateSamlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn auth_method_update_universal_identity(configuration: &configuration::Configuration, auth_method_update_universal_identity: models::AuthMethodUpdateUniversalIdentity) -> Result<models::AuthMethodUpdateOutput, Error<AuthMethodUpdateUniversalIdentityError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_auth_method_update_universal_identity = auth_method_update_universal_identity;

    let uri_str = format!("{}/auth-method-update-universal-identity", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_auth_method_update_universal_identity);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethodUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethodUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<AuthMethodUpdateUniversalIdentityError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn calc_password_security_info(configuration: &configuration::Configuration, calc_password_security_info: models::CalcPasswordSecurityInfo) -> Result<models::PasswordSecurityInfo, Error<CalcPasswordSecurityInfoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_calc_password_security_info = calc_password_security_info;

    let uri_str = format!("{}/calc-password-security-info", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_calc_password_security_info);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PasswordSecurityInfo`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::PasswordSecurityInfo`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CalcPasswordSecurityInfoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn certificate_discovery(configuration: &configuration::Configuration, certificate_discovery: models::CertificateDiscovery) -> Result<models::CertificateDiscoveryOutput, Error<CertificateDiscoveryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_certificate_discovery = certificate_discovery;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_certificate_discovery);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CertificateDiscoveryOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CertificateDiscoveryOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CertificateDiscoveryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn change_admin_account_password(configuration: &configuration::Configuration, change_admin_account_password: models::ChangeAdminAccountPassword) -> Result<serde_json::Value, Error<ChangeAdminAccountPasswordError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_change_admin_account_password = change_admin_account_password;

    let uri_str = format!("{}/change-admin-account-password", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_change_admin_account_password);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ChangeAdminAccountPasswordError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn configure(configuration: &configuration::Configuration, configure: models::Configure) -> Result<models::ConfigureOutput, Error<ConfigureError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_configure = configure;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_configure);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ConfigureOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ConfigureOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ConfigureError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn connect(configuration: &configuration::Configuration, connect: models::Connect) -> Result<serde_json::Value, Error<ConnectError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_connect = connect;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_connect);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ConnectError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_artifactory_target(configuration: &configuration::Configuration, create_artifactory_target: models::CreateArtifactoryTarget) -> Result<models::CreateArtifactoryTargetOutput, Error<CreateArtifactoryTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_artifactory_target = create_artifactory_target;

    let uri_str = format!("{}/create-artifactory-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_artifactory_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateArtifactoryTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateArtifactoryTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateArtifactoryTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method(configuration: &configuration::Configuration, create_auth_method: models::CreateAuthMethod) -> Result<models::CreateAuthMethodOutput, Error<CreateAuthMethodError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method = create_auth_method;

    let uri_str = format!("{}/create-auth-method", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_awsiam(configuration: &configuration::Configuration, create_auth_method_awsiam: models::CreateAuthMethodAwsiam) -> Result<models::CreateAuthMethodAwsiamOutput, Error<CreateAuthMethodAwsiamError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_awsiam = create_auth_method_awsiam;

    let uri_str = format!("{}/create-auth-method-aws-iam", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_awsiam);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodAwsiamOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodAwsiamOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodAwsiamError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_azure_ad(configuration: &configuration::Configuration, create_auth_method_azure_ad: models::CreateAuthMethodAzureAd) -> Result<models::CreateAuthMethodAzureAdOutput, Error<CreateAuthMethodAzureAdError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_azure_ad = create_auth_method_azure_ad;

    let uri_str = format!("{}/create-auth-method-azure-ad", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_azure_ad);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodAzureAdOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodAzureAdOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodAzureAdError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_cert(configuration: &configuration::Configuration, create_auth_method_cert: models::CreateAuthMethodCert) -> Result<models::CreateAuthMethodCertOutput, Error<CreateAuthMethodCertError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_cert = create_auth_method_cert;

    let uri_str = format!("{}/create-auth-method-cert", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_cert);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodCertOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodCertOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodCertError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_email(configuration: &configuration::Configuration, create_auth_method_email: models::CreateAuthMethodEmail) -> Result<models::CreateAuthMethodEmailOutput, Error<CreateAuthMethodEmailError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_email = create_auth_method_email;

    let uri_str = format!("{}/create-auth-method-email", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_email);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodEmailOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodEmailOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodEmailError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_gcp(configuration: &configuration::Configuration, create_auth_method_gcp: models::CreateAuthMethodGcp) -> Result<models::CreateAuthMethodGcpOutput, Error<CreateAuthMethodGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_gcp = create_auth_method_gcp;

    let uri_str = format!("{}/create-auth-method-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_gcp);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodGcpOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodGcpOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_huawei(configuration: &configuration::Configuration, create_auth_method_huawei: models::CreateAuthMethodHuawei) -> Result<models::CreateAuthMethodHuaweiOutput, Error<CreateAuthMethodHuaweiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_huawei = create_auth_method_huawei;

    let uri_str = format!("{}/create-auth-method-huawei", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_huawei);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodHuaweiOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodHuaweiOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodHuaweiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_k8_s(configuration: &configuration::Configuration, create_auth_method_k8_s: models::CreateAuthMethodK8S) -> Result<models::CreateAuthMethodK8SOutput, Error<CreateAuthMethodK8SError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_k8_s = create_auth_method_k8_s;

    let uri_str = format!("{}/create-auth-method-k8s", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_k8_s);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodK8SOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodK8SOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodK8SError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_ldap(configuration: &configuration::Configuration, create_auth_method_ldap: models::CreateAuthMethodLdap) -> Result<models::CreateAuthMethodLdapOutput, Error<CreateAuthMethodLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_ldap = create_auth_method_ldap;

    let uri_str = format!("{}/create-auth-method-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_ldap);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodLdapOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodLdapOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_o_auth2(configuration: &configuration::Configuration, create_auth_method_o_auth2: models::CreateAuthMethodOAuth2) -> Result<models::CreateAuthMethodOAuth2Output, Error<CreateAuthMethodOAuth2Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_o_auth2 = create_auth_method_o_auth2;

    let uri_str = format!("{}/create-auth-method-oauth2", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_o_auth2);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodOAuth2Output`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodOAuth2Output`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodOAuth2Error> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_oci(configuration: &configuration::Configuration, create_auth_method_oci: models::CreateAuthMethodOci) -> Result<models::CreateAuthMethodOciOutput, Error<CreateAuthMethodOciError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_oci = create_auth_method_oci;

    let uri_str = format!("{}/create-auth-method-oci", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_oci);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodOciOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodOciOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodOciError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_oidc(configuration: &configuration::Configuration, create_auth_method_oidc: models::CreateAuthMethodOidc) -> Result<models::CreateAuthMethodOidcOutput, Error<CreateAuthMethodOidcError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_oidc = create_auth_method_oidc;

    let uri_str = format!("{}/create-auth-method-oidc", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_oidc);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodOidcOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodOidcOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodOidcError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_saml(configuration: &configuration::Configuration, create_auth_method_saml: models::CreateAuthMethodSaml) -> Result<models::CreateAuthMethodSamlOutput, Error<CreateAuthMethodSamlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_saml = create_auth_method_saml;

    let uri_str = format!("{}/create-auth-method-saml", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_saml);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodSamlOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodSamlOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodSamlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_auth_method_universal_identity(configuration: &configuration::Configuration, create_auth_method_universal_identity: models::CreateAuthMethodUniversalIdentity) -> Result<models::CreateAuthMethodUniversalIdentityOutput, Error<CreateAuthMethodUniversalIdentityError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_auth_method_universal_identity = create_auth_method_universal_identity;

    let uri_str = format!("{}/create-auth-method-universal-identity", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_auth_method_universal_identity);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAuthMethodUniversalIdentityOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAuthMethodUniversalIdentityOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAuthMethodUniversalIdentityError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_aws_target(configuration: &configuration::Configuration, create_aws_target: models::CreateAwsTarget) -> Result<models::CreateAwsTargetOutput, Error<CreateAwsTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_aws_target = create_aws_target;

    let uri_str = format!("{}/create-aws-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_aws_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAwsTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAwsTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAwsTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_azure_target(configuration: &configuration::Configuration, create_azure_target: models::CreateAzureTarget) -> Result<models::CreateAzureTargetOutput, Error<CreateAzureTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_azure_target = create_azure_target;

    let uri_str = format!("{}/create-azure-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_azure_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateAzureTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateAzureTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateAzureTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_certificate(configuration: &configuration::Configuration, create_certificate: models::CreateCertificate) -> Result<models::CreateCertificateOutput, Error<CreateCertificateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_certificate = create_certificate;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_certificate);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateCertificateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateCertificateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateCertificateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_classic_key(configuration: &configuration::Configuration, create_classic_key: models::CreateClassicKey) -> Result<models::CreateClassicKeyOutput, Error<CreateClassicKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_classic_key = create_classic_key;

    let uri_str = format!("{}/create-classic-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_classic_key);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateClassicKeyOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateClassicKeyOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateClassicKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_db_target(configuration: &configuration::Configuration, create_db_target: models::CreateDbTarget) -> Result<models::CreateDbTargetOutput, Error<CreateDbTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_db_target = create_db_target;

    let uri_str = format!("{}/create-db-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_db_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateDbTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateDbTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateDbTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_dfc_key(configuration: &configuration::Configuration, create_dfc_key: models::CreateDfcKey) -> Result<models::CreateDfcKeyOutput, Error<CreateDfcKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_dfc_key = create_dfc_key;

    let uri_str = format!("{}/create-dfc-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_dfc_key);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateDfcKeyOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateDfcKeyOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateDfcKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_dockerhub_target(configuration: &configuration::Configuration, create_dockerhub_target: models::CreateDockerhubTarget) -> Result<models::CreateDockerhubTargetOutput, Error<CreateDockerhubTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_dockerhub_target = create_dockerhub_target;

    let uri_str = format!("{}/create-dockerhub-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_dockerhub_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateDockerhubTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateDockerhubTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateDockerhubTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_dynamic_secret(configuration: &configuration::Configuration, create_dynamic_secret: models::CreateDynamicSecret) -> Result<serde_json::Value, Error<CreateDynamicSecretError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_dynamic_secret = create_dynamic_secret;

    let uri_str = format!("{}/create-dynamic-secret", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_dynamic_secret);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateDynamicSecretError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_eks_target(configuration: &configuration::Configuration, create_eks_target: models::CreateEksTarget) -> Result<models::CreateEksTargetOutput, Error<CreateEksTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_eks_target = create_eks_target;

    let uri_str = format!("{}/create-eks-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_eks_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateEksTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateEksTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateEksTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_esm(configuration: &configuration::Configuration, create_esm: models::CreateEsm) -> Result<models::CreateEsmOutput, Error<CreateEsmError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_esm = create_esm;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_esm);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateEsmOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateEsmOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateEsmError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_event_forwarder(configuration: &configuration::Configuration, create_event_forwarder: models::CreateEventForwarder) -> Result<models::CreateEventForwarderOutput, Error<CreateEventForwarderError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_event_forwarder = create_event_forwarder;

    let uri_str = format!("{}/create-event-forwarder", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_event_forwarder);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateEventForwarderOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateEventForwarderOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateEventForwarderError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_gcp_target(configuration: &configuration::Configuration, create_gcp_target: models::CreateGcpTarget) -> Result<models::CreateGcpTargetOutput, Error<CreateGcpTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_gcp_target = create_gcp_target;

    let uri_str = format!("{}/create-gcp-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_gcp_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateGcpTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateGcpTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateGcpTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_github_target(configuration: &configuration::Configuration, create_github_target: models::CreateGithubTarget) -> Result<models::CreateGithubTargetOutput, Error<CreateGithubTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_github_target = create_github_target;

    let uri_str = format!("{}/create-github-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_github_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateGithubTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateGithubTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateGithubTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_gitlab_target(configuration: &configuration::Configuration, create_gitlab_target: models::CreateGitlabTarget) -> Result<models::CreateGitlabTargetOutput, Error<CreateGitlabTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_gitlab_target = create_gitlab_target;

    let uri_str = format!("{}/create-gitlab-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_gitlab_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateGitlabTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateGitlabTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateGitlabTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_gke_target(configuration: &configuration::Configuration, create_gke_target: models::CreateGkeTarget) -> Result<models::CreateGkeTargetOutput, Error<CreateGkeTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_gke_target = create_gke_target;

    let uri_str = format!("{}/create-gke-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_gke_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateGkeTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateGkeTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateGkeTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_global_sign_atlas_target(configuration: &configuration::Configuration, create_global_sign_atlas_target: models::CreateGlobalSignAtlasTarget) -> Result<models::CreateGlobalSignAtlasTargetOutput, Error<CreateGlobalSignAtlasTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_global_sign_atlas_target = create_global_sign_atlas_target;

    let uri_str = format!("{}/create-globalsign-atlas-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_global_sign_atlas_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateGlobalSignAtlasTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateGlobalSignAtlasTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateGlobalSignAtlasTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_global_sign_target(configuration: &configuration::Configuration, create_global_sign_target: models::CreateGlobalSignTarget) -> Result<models::CreateGlobalSignTargetOutput, Error<CreateGlobalSignTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_global_sign_target = create_global_sign_target;

    let uri_str = format!("{}/create-globalsign-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_global_sign_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateGlobalSignTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateGlobalSignTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateGlobalSignTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_godaddy_target(configuration: &configuration::Configuration, create_godaddy_target: models::CreateGodaddyTarget) -> Result<models::CreateGodaddyTargetOutput, Error<CreateGodaddyTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_godaddy_target = create_godaddy_target;

    let uri_str = format!("{}/create-godaddy-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_godaddy_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateGodaddyTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateGodaddyTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateGodaddyTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_group(configuration: &configuration::Configuration, create_group: models::CreateGroup) -> Result<models::CreateGroupOutput, Error<CreateGroupError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_group = create_group;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_group);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateGroupOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateGroupOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateGroupError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_hashi_vault_target(configuration: &configuration::Configuration, create_hashi_vault_target: models::CreateHashiVaultTarget) -> Result<models::CreateHashiVaultTargetOutput, Error<CreateHashiVaultTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_hashi_vault_target = create_hashi_vault_target;

    let uri_str = format!("{}/create-hashi-vault-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_hashi_vault_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateHashiVaultTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateHashiVaultTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateHashiVaultTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_key(configuration: &configuration::Configuration, create_key: models::CreateKey) -> Result<models::CreateKeyOutput, Error<CreateKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_key = create_key;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_key);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateKeyOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateKeyOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_linked_target(configuration: &configuration::Configuration, create_linked_target: models::CreateLinkedTarget) -> Result<models::CreateLinkedTargetOutput, Error<CreateLinkedTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_linked_target = create_linked_target;

    let uri_str = format!("{}/create-linked-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_linked_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateLinkedTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateLinkedTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateLinkedTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_native_k8_s_target(configuration: &configuration::Configuration, create_native_k8_s_target: models::CreateNativeK8STarget) -> Result<models::CreateNativeK8STargetOutput, Error<CreateNativeK8STargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_native_k8_s_target = create_native_k8_s_target;

    let uri_str = format!("{}/create-k8s-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_native_k8_s_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateNativeK8STargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateNativeK8STargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateNativeK8STargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_oidc_app(configuration: &configuration::Configuration, create_oidc_app: models::CreateOidcApp) -> Result<models::CreateOidcAppOutput, Error<CreateOidcAppError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_oidc_app = create_oidc_app;

    let uri_str = format!("{}/create-oidc-app", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_oidc_app);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateOidcAppOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateOidcAppOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateOidcAppError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_passkey(configuration: &configuration::Configuration, create_passkey: models::CreatePasskey) -> Result<models::CreatePasskeyOutput, Error<CreatePasskeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_passkey = create_passkey;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_passkey);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreatePasskeyOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreatePasskeyOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreatePasskeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_ping_target(configuration: &configuration::Configuration, create_ping_target: models::CreatePingTarget) -> Result<models::CreatePingTargetOutput, Error<CreatePingTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_ping_target = create_ping_target;

    let uri_str = format!("{}/create-ping-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_ping_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreatePingTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreatePingTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreatePingTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_pki_cert_issuer(configuration: &configuration::Configuration, create_pki_cert_issuer: models::CreatePkiCertIssuer) -> Result<models::CreatePkiCertIssuerOutput, Error<CreatePkiCertIssuerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_pki_cert_issuer = create_pki_cert_issuer;

    let uri_str = format!("{}/create-pki-cert-issuer", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_pki_cert_issuer);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreatePkiCertIssuerOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreatePkiCertIssuerOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreatePkiCertIssuerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_rabbit_mq_target(configuration: &configuration::Configuration, create_rabbit_mq_target: models::CreateRabbitMqTarget) -> Result<models::CreateRabbitMqTargetOutput, Error<CreateRabbitMqTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_rabbit_mq_target = create_rabbit_mq_target;

    let uri_str = format!("{}/create-rabbitmq-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_rabbit_mq_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateRabbitMqTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateRabbitMqTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateRabbitMqTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_role(configuration: &configuration::Configuration, create_role: models::CreateRole) -> Result<serde_json::Value, Error<CreateRoleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_role = create_role;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_role);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateRoleError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_rotated_secret(configuration: &configuration::Configuration, create_rotated_secret: models::CreateRotatedSecret) -> Result<models::CreateRotatedSecretOutput, Error<CreateRotatedSecretError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_rotated_secret = create_rotated_secret;

    let uri_str = format!("{}/create-rotated-secret", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_rotated_secret);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateRotatedSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateRotatedSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateRotatedSecretError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_salesforce_target(configuration: &configuration::Configuration, create_salesforce_target: models::CreateSalesforceTarget) -> Result<models::CreateSalesforceTargetOutput, Error<CreateSalesforceTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_salesforce_target = create_salesforce_target;

    let uri_str = format!("{}/create-salesforce-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_salesforce_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateSalesforceTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateSalesforceTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateSalesforceTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_secret(configuration: &configuration::Configuration, create_secret: models::CreateSecret) -> Result<models::CreateSecretOutput, Error<CreateSecretError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_secret = create_secret;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_secret);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateSecretError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_ssh_cert_issuer(configuration: &configuration::Configuration, create_ssh_cert_issuer: models::CreateSshCertIssuer) -> Result<models::CreateSshCertIssuerOutput, Error<CreateSshCertIssuerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_ssh_cert_issuer = create_ssh_cert_issuer;

    let uri_str = format!("{}/create-ssh-cert-issuer", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_ssh_cert_issuer);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateSshCertIssuerOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateSshCertIssuerOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateSshCertIssuerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_ssh_target(configuration: &configuration::Configuration, create_ssh_target: models::CreateSshTarget) -> Result<models::CreateSshTargetOutput, Error<CreateSshTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_ssh_target = create_ssh_target;

    let uri_str = format!("{}/create-ssh-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_ssh_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateSshTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateSshTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateSshTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_tokenizer(configuration: &configuration::Configuration, create_tokenizer: models::CreateTokenizer) -> Result<models::CreateTokenizerOutput, Error<CreateTokenizerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_tokenizer = create_tokenizer;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_tokenizer);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateTokenizerOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateTokenizerOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateTokenizerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_usc(configuration: &configuration::Configuration, create_usc: models::CreateUsc) -> Result<models::CreateUscOutput, Error<CreateUscError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_usc = create_usc;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_usc);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateUscOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateUscOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateUscError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_user_event(configuration: &configuration::Configuration, create_user_event: models::CreateUserEvent) -> Result<models::CreateUserEventOutput, Error<CreateUserEventError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_user_event = create_user_event;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_user_event);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateUserEventOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateUserEventOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateUserEventError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_web_target(configuration: &configuration::Configuration, create_web_target: models::CreateWebTarget) -> Result<models::CreateWebTargetOutput, Error<CreateWebTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_web_target = create_web_target;

    let uri_str = format!("{}/create-web-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_web_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateWebTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateWebTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateWebTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_windows_target(configuration: &configuration::Configuration, create_windows_target: models::CreateWindowsTarget) -> Result<models::CreateWindowsTargetOutput, Error<CreateWindowsTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_windows_target = create_windows_target;

    let uri_str = format!("{}/create-windows-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_windows_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateWindowsTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateWindowsTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateWindowsTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn create_zero_ssl_target(configuration: &configuration::Configuration, create_zero_ssl_target: models::CreateZeroSslTarget) -> Result<models::CreateZeroSslTargetOutput, Error<CreateZeroSslTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_zero_ssl_target = create_zero_ssl_target;

    let uri_str = format!("{}/create-zerossl-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_zero_ssl_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateZeroSslTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateZeroSslTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateZeroSslTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn createldap_target(configuration: &configuration::Configuration, create_ldap_target: models::CreateLdapTarget) -> Result<models::CreateLdapTargetOutput, Error<CreateldapTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_create_ldap_target = create_ldap_target;

    let uri_str = format!("{}/create-ldap-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_create_ldap_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CreateLdapTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CreateLdapTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<CreateldapTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn deactivate_acme_account(configuration: &configuration::Configuration, deactivate_acme_account: models::DeactivateAcmeAccount) -> Result<serde_json::Value, Error<DeactivateAcmeAccountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_deactivate_acme_account = deactivate_acme_account;

    let uri_str = format!("{}/deactivate-acme-account", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_deactivate_acme_account);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeactivateAcmeAccountError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn decrypt(configuration: &configuration::Configuration, decrypt: models::Decrypt) -> Result<models::DecryptOutput, Error<DecryptError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_decrypt = decrypt;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_decrypt);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DecryptOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DecryptOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DecryptError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn decrypt_batch(configuration: &configuration::Configuration, batch_encryption_request_line: Vec<models::BatchEncryptionRequestLine>) -> Result<models::DecryptOutput, Error<DecryptBatchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_batch_encryption_request_line = batch_encryption_request_line;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_batch_encryption_request_line);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DecryptOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DecryptOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DecryptBatchError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn decrypt_gpg(configuration: &configuration::Configuration, decrypt_gpg: models::DecryptGpg) -> Result<models::DecryptGpgOutput, Error<DecryptGpgError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_decrypt_gpg = decrypt_gpg;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_decrypt_gpg);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DecryptGpgOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DecryptGpgOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DecryptGpgError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn decrypt_pkcs1(configuration: &configuration::Configuration, decrypt_pkcs1: models::DecryptPkcs1) -> Result<models::DecryptPkcs1Output, Error<DecryptPkcs1Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_decrypt_pkcs1 = decrypt_pkcs1;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_decrypt_pkcs1);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DecryptPkcs1Output`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DecryptPkcs1Output`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DecryptPkcs1Error> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn decrypt_with_classic_key(configuration: &configuration::Configuration, decrypt_with_classic_key: models::DecryptWithClassicKey) -> Result<models::DecryptWithClassicKeyOutput, Error<DecryptWithClassicKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_decrypt_with_classic_key = decrypt_with_classic_key;

    let uri_str = format!("{}/decrypt-with-classic-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_decrypt_with_classic_key);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DecryptWithClassicKeyOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DecryptWithClassicKeyOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DecryptWithClassicKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_auth_method(configuration: &configuration::Configuration, delete_auth_method: models::DeleteAuthMethod) -> Result<models::DeleteAuthMethodOutput, Error<DeleteAuthMethodError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_auth_method = delete_auth_method;

    let uri_str = format!("{}/delete-auth-method", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_auth_method);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteAuthMethodOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteAuthMethodOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteAuthMethodError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_auth_methods(configuration: &configuration::Configuration, delete_auth_methods: models::DeleteAuthMethods) -> Result<models::DeleteAuthMethodsOutput, Error<DeleteAuthMethodsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_auth_methods = delete_auth_methods;

    let uri_str = format!("{}/delete-auth-methods", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_auth_methods);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteAuthMethodsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteAuthMethodsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteAuthMethodsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_event_forwarder(configuration: &configuration::Configuration, delete_event_forwarder: models::DeleteEventForwarder) -> Result<serde_json::Value, Error<DeleteEventForwarderError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_event_forwarder = delete_event_forwarder;

    let uri_str = format!("{}/delete-event-forwarder", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_event_forwarder);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteEventForwarderError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_gateway_allowed_access_id(configuration: &configuration::Configuration, delete_gateway_allowed_access_id: models::DeleteGatewayAllowedAccessId) -> Result<serde_json::Value, Error<DeleteGatewayAllowedAccessIdError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_gateway_allowed_access_id = delete_gateway_allowed_access_id;

    let uri_str = format!("{}/gateway-delete-allowed-management-access", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_gateway_allowed_access_id);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteGatewayAllowedAccessIdError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_group(configuration: &configuration::Configuration, delete_group: models::DeleteGroup) -> Result<models::DeleteGroupOutput, Error<DeleteGroupError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_group = delete_group;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_group);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteGroupOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteGroupOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteGroupError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_gw_cluster(configuration: &configuration::Configuration, delete_gw_cluster: models::DeleteGwCluster) -> Result<serde_json::Value, Error<DeleteGwClusterError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_gw_cluster = delete_gw_cluster;

    let uri_str = format!("{}/delete-gateway-cluster", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_gw_cluster);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteGwClusterError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_item(configuration: &configuration::Configuration, delete_item: models::DeleteItem) -> Result<models::DeleteItemOutput, Error<DeleteItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_item = delete_item;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_item);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteItemOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteItemOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteItemError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_items(configuration: &configuration::Configuration, delete_items: models::DeleteItems) -> Result<models::DeleteItemsOutput, Error<DeleteItemsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_items = delete_items;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_items);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteItemsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteItemsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteItemsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_role(configuration: &configuration::Configuration, delete_role: models::DeleteRole) -> Result<serde_json::Value, Error<DeleteRoleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_role = delete_role;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_role);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteRoleError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_role_association(configuration: &configuration::Configuration, delete_role_association: models::DeleteRoleAssociation) -> Result<serde_json::Value, Error<DeleteRoleAssociationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_role_association = delete_role_association;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_role_association);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteRoleAssociationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_role_rule(configuration: &configuration::Configuration, delete_role_rule: models::DeleteRoleRule) -> Result<models::DeleteRoleRuleOutput, Error<DeleteRoleRuleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_role_rule = delete_role_rule;

    let uri_str = format!("{}/delete-role-rule", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_role_rule);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteRoleRuleOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteRoleRuleOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteRoleRuleError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_roles(configuration: &configuration::Configuration, delete_roles: models::DeleteRoles) -> Result<serde_json::Value, Error<DeleteRolesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_roles = delete_roles;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_roles);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteRolesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_target(configuration: &configuration::Configuration, delete_target: models::DeleteTarget) -> Result<serde_json::Value, Error<DeleteTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_target = delete_target;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_target);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_target_association(configuration: &configuration::Configuration, delete_target_association: models::DeleteTargetAssociation) -> Result<serde_json::Value, Error<DeleteTargetAssociationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_target_association = delete_target_association;

    let uri_str = format!("{}/delete-assoc-target-item", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_target_association);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteTargetAssociationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn delete_targets(configuration: &configuration::Configuration, delete_targets: models::DeleteTargets) -> Result<serde_json::Value, Error<DeleteTargetsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_delete_targets = delete_targets;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_delete_targets);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeleteTargetsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn derive_key(configuration: &configuration::Configuration, derive_key: models::DeriveKey) -> Result<models::DeriveKeyOutput, Error<DeriveKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_derive_key = derive_key;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_derive_key);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeriveKeyOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeriveKeyOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DeriveKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn describe_assoc(configuration: &configuration::Configuration, describe_assoc: models::DescribeAssoc) -> Result<models::RoleAssociationDetails, Error<DescribeAssocError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_describe_assoc = describe_assoc;

    let uri_str = format!("{}/describe-role-am-assoc", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_describe_assoc);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RoleAssociationDetails`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RoleAssociationDetails`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DescribeAssocError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn describe_item(configuration: &configuration::Configuration, describe_item: models::DescribeItem) -> Result<models::Item, Error<DescribeItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_describe_item = describe_item;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_describe_item);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Item`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Item`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DescribeItemError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn describe_permissions(configuration: &configuration::Configuration, describe_permissions: models::DescribePermissions) -> Result<models::DescribePermissionsOutput, Error<DescribePermissionsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_describe_permissions = describe_permissions;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_describe_permissions);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DescribePermissionsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DescribePermissionsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DescribePermissionsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn describe_sub_claims(configuration: &configuration::Configuration, describe_sub_claims: models::DescribeSubClaims) -> Result<models::DescribeSubClaimsOutput, Error<DescribeSubClaimsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_describe_sub_claims = describe_sub_claims;

    let uri_str = format!("{}/describe-sub-claims", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_describe_sub_claims);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DescribeSubClaimsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DescribeSubClaimsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DescribeSubClaimsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn detokenize(configuration: &configuration::Configuration, detokenize: models::Detokenize) -> Result<models::DetokenizeOutput, Error<DetokenizeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_detokenize = detokenize;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_detokenize);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DetokenizeOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DetokenizeOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DetokenizeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn detokenize_batch(configuration: &configuration::Configuration, batch_tokenization_request_line: Vec<models::BatchTokenizationRequestLine>) -> Result<models::DetokenizeOutput, Error<DetokenizeBatchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_batch_tokenization_request_line = batch_tokenization_request_line;

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

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_batch_tokenization_request_line);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DetokenizeOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DetokenizeOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DetokenizeBatchError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_artifactory(configuration: &configuration::Configuration, dynamic_secret_create_artifactory: models::DynamicSecretCreateArtifactory) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateArtifactoryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_artifactory = dynamic_secret_create_artifactory;

    let uri_str = format!("{}/dynamic-secret-create-artifactory", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_artifactory);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateArtifactoryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_aws(configuration: &configuration::Configuration, dynamic_secret_create_aws: models::DynamicSecretCreateAws) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateAwsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_aws = dynamic_secret_create_aws;

    let uri_str = format!("{}/dynamic-secret-create-aws", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_aws);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateAwsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_azure(configuration: &configuration::Configuration, dynamic_secret_create_azure: models::DynamicSecretCreateAzure) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateAzureError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_azure = dynamic_secret_create_azure;

    let uri_str = format!("{}/dynamic-secret-create-azure", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_azure);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateAzureError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_cassandra(configuration: &configuration::Configuration, dynamic_secret_create_cassandra: models::DynamicSecretCreateCassandra) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateCassandraError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_cassandra = dynamic_secret_create_cassandra;

    let uri_str = format!("{}/dynamic-secret-create-cassandra", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_cassandra);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateCassandraError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_custom(configuration: &configuration::Configuration, dynamic_secret_create_custom: Option<models::DynamicSecretCreateCustom>) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateCustomError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_custom = dynamic_secret_create_custom;

    let uri_str = format!("{}/dynamic-secret-create-custom", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_custom);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateCustomError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_dockerhub(configuration: &configuration::Configuration, dynamic_secret_create_dockerhub: models::DynamicSecretCreateDockerhub) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateDockerhubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_dockerhub = dynamic_secret_create_dockerhub;

    let uri_str = format!("{}/dynamic-secret-create-dockerhub", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_dockerhub);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateDockerhubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_eks(configuration: &configuration::Configuration, dynamic_secret_create_eks: models::DynamicSecretCreateEks) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateEksError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_eks = dynamic_secret_create_eks;

    let uri_str = format!("{}/dynamic-secret-create-eks", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_eks);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateEksError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_gcp(configuration: &configuration::Configuration, dynamic_secret_create_gcp: models::DynamicSecretCreateGcp) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_gcp = dynamic_secret_create_gcp;

    let uri_str = format!("{}/dynamic-secret-create-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_gcp);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_github(configuration: &configuration::Configuration, dynamic_secret_create_github: models::DynamicSecretCreateGithub) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateGithubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_github = dynamic_secret_create_github;

    let uri_str = format!("{}/dynamic-secret-create-github", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_github);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateGithubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_gitlab(configuration: &configuration::Configuration, dynamic_secret_create_gitlab: models::DynamicSecretCreateGitlab) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateGitlabError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_gitlab = dynamic_secret_create_gitlab;

    let uri_str = format!("{}/dynamic-secret-create-gitlab", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_gitlab);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateGitlabError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_gke(configuration: &configuration::Configuration, dynamic_secret_create_gke: models::DynamicSecretCreateGke) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateGkeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_gke = dynamic_secret_create_gke;

    let uri_str = format!("{}/dynamic-secret-create-gke", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_gke);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateGkeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_google_workspace(configuration: &configuration::Configuration, dynamic_secret_create_google_workspace: models::DynamicSecretCreateGoogleWorkspace) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateGoogleWorkspaceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_google_workspace = dynamic_secret_create_google_workspace;

    let uri_str = format!("{}/dynamic-secret-create-google-workspace", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_google_workspace);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateGoogleWorkspaceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_hana_db(configuration: &configuration::Configuration, dynamic_secret_create_hana_db: models::DynamicSecretCreateHanaDb) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateHanaDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_hana_db = dynamic_secret_create_hana_db;

    let uri_str = format!("{}/dynamic-secret-create-hanadb", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_hana_db);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateHanaDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_k8s(configuration: &configuration::Configuration, dynamic_secret_create_k8s: models::DynamicSecretCreateK8s) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateK8sError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_k8s = dynamic_secret_create_k8s;

    let uri_str = format!("{}/dynamic-secret-create-k8s", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_k8s);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateK8sError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_ldap(configuration: &configuration::Configuration, dynamic_secret_create_ldap: models::DynamicSecretCreateLdap) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_ldap = dynamic_secret_create_ldap;

    let uri_str = format!("{}/dynamic-secret-create-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_ldap);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_mongo_db(configuration: &configuration::Configuration, dynamic_secret_create_mongo_db: models::DynamicSecretCreateMongoDb) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateMongoDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_mongo_db = dynamic_secret_create_mongo_db;

    let uri_str = format!("{}/dynamic-secret-create-mongodb", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_mongo_db);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateMongoDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_ms_sql(configuration: &configuration::Configuration, dynamic_secret_create_ms_sql: models::DynamicSecretCreateMsSql) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateMsSqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_ms_sql = dynamic_secret_create_ms_sql;

    let uri_str = format!("{}/dynamic-secret-create-mssql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_ms_sql);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateMsSqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_my_sql(configuration: &configuration::Configuration, dynamic_secret_create_my_sql: models::DynamicSecretCreateMySql) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateMySqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_my_sql = dynamic_secret_create_my_sql;

    let uri_str = format!("{}/dynamic-secret-create-mysql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_my_sql);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateMySqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_open_ai(configuration: &configuration::Configuration, dynamic_secret_create_open_ai: models::DynamicSecretCreateOpenAi) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateOpenAiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_open_ai = dynamic_secret_create_open_ai;

    let uri_str = format!("{}/dynamic-secret-create-openai", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_open_ai);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateOpenAiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_oracle_db(configuration: &configuration::Configuration, dynamic_secret_create_oracle_db: models::DynamicSecretCreateOracleDb) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateOracleDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_oracle_db = dynamic_secret_create_oracle_db;

    let uri_str = format!("{}/dynamic-secret-create-oracle", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_oracle_db);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateOracleDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_ping(configuration: &configuration::Configuration, dynamic_secret_create_ping: models::DynamicSecretCreatePing) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreatePingError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_ping = dynamic_secret_create_ping;

    let uri_str = format!("{}/dynamic-secret-create-ping", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_ping);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreatePingError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_postgre_sql(configuration: &configuration::Configuration, dynamic_secret_create_postgre_sql: models::DynamicSecretCreatePostgreSql) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreatePostgreSqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_postgre_sql = dynamic_secret_create_postgre_sql;

    let uri_str = format!("{}/dynamic-secret-create-postgresql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_postgre_sql);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreatePostgreSqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_rabbit_mq(configuration: &configuration::Configuration, dynamic_secret_create_rabbit_mq: models::DynamicSecretCreateRabbitMq) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateRabbitMqError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_rabbit_mq = dynamic_secret_create_rabbit_mq;

    let uri_str = format!("{}/dynamic-secret-create-rabbitmq", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_rabbit_mq);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateRabbitMqError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_rdp(configuration: &configuration::Configuration, dynamic_secret_create_rdp: models::DynamicSecretCreateRdp) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateRdpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_rdp = dynamic_secret_create_rdp;

    let uri_str = format!("{}/dynamic-secret-create-rdp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_rdp);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateRdpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_redis(configuration: &configuration::Configuration, dynamic_secret_create_redis: models::DynamicSecretCreateRedis) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateRedisError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_redis = dynamic_secret_create_redis;

    let uri_str = format!("{}/dynamic-secret-create-redis", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_redis);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateRedisError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_redshift(configuration: &configuration::Configuration, dynamic_secret_create_redshift: models::DynamicSecretCreateRedshift) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateRedshiftError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_redshift = dynamic_secret_create_redshift;

    let uri_str = format!("{}/dynamic-secret-create-redshift", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_redshift);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateRedshiftError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_snowflake(configuration: &configuration::Configuration, dynamic_secret_create_snowflake: models::DynamicSecretCreateSnowflake) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateSnowflakeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_snowflake = dynamic_secret_create_snowflake;

    let uri_str = format!("{}/dynamic-secret-create-snowflake", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_snowflake);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateSnowflakeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_create_venafi(configuration: &configuration::Configuration, dynamic_secret_create_venafi: models::DynamicSecretCreateVenafi) -> Result<models::DynamicSecretCreateOutput, Error<DynamicSecretCreateVenafiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_create_venafi = dynamic_secret_create_venafi;

    let uri_str = format!("{}/dynamic-secret-create-venafi", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_create_venafi);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretCreateVenafiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_delete(configuration: &configuration::Configuration, dynamic_secret_delete: models::DynamicSecretDelete) -> Result<models::DynamicSecretDeleteOutput, Error<DynamicSecretDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_delete = dynamic_secret_delete;

    let uri_str = format!("{}/dynamic-secret-delete", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_delete);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretDeleteOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretDeleteOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_get(configuration: &configuration::Configuration, dynamic_secret_get: models::DynamicSecretGet) -> Result<models::DsProducerDetails, Error<DynamicSecretGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_get = dynamic_secret_get;

    let uri_str = format!("{}/dynamic-secret-get", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_get);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DsProducerDetails`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DsProducerDetails`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_get_value(configuration: &configuration::Configuration, dynamic_secret_get_value: models::DynamicSecretGetValue) -> Result<std::collections::HashMap<String, String>, Error<DynamicSecretGetValueError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_get_value = dynamic_secret_get_value;

    let uri_str = format!("{}/dynamic-secret-get-value", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_get_value);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap&lt;String, String&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap&lt;String, String&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretGetValueError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_list(configuration: &configuration::Configuration, dynamic_secret_list: models::DynamicSecretList) -> Result<models::GetProducersListReplyObj, Error<DynamicSecretListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_list = dynamic_secret_list;

    let uri_str = format!("{}/dynamic-secret-list", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_list);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetProducersListReplyObj`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetProducersListReplyObj`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_tmp_creds_delete(configuration: &configuration::Configuration, dynamic_secret_tmp_creds_delete: models::DynamicSecretTmpCredsDelete) -> Result<(), Error<DynamicSecretTmpCredsDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_tmp_creds_delete = dynamic_secret_tmp_creds_delete;

    let uri_str = format!("{}/dynamic-secret-tmp-creds-delete", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_tmp_creds_delete);

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretTmpCredsDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_tmp_creds_get(configuration: &configuration::Configuration, dynamic_secret_tmp_creds_get: models::DynamicSecretTmpCredsGet) -> Result<Vec<models::TmpUserData>, Error<DynamicSecretTmpCredsGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_tmp_creds_get = dynamic_secret_tmp_creds_get;

    let uri_str = format!("{}/dynamic-secret-tmp-creds-Get", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_tmp_creds_get);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::TmpUserData&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::TmpUserData&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretTmpCredsGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_tmp_creds_update(configuration: &configuration::Configuration, dynamic_secret_tmp_creds_update: models::DynamicSecretTmpCredsUpdate) -> Result<(), Error<DynamicSecretTmpCredsUpdateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_tmp_creds_update = dynamic_secret_tmp_creds_update;

    let uri_str = format!("{}/dynamic-secret-tmp-creds-update", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_tmp_creds_update);

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretTmpCredsUpdateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_artifactory(configuration: &configuration::Configuration, dynamic_secret_update_artifactory: models::DynamicSecretUpdateArtifactory) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateArtifactoryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_artifactory = dynamic_secret_update_artifactory;

    let uri_str = format!("{}/dynamic-secret-update-artifactory", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_artifactory);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateArtifactoryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_aws(configuration: &configuration::Configuration, dynamic_secret_update_aws: models::DynamicSecretUpdateAws) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateAwsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_aws = dynamic_secret_update_aws;

    let uri_str = format!("{}/dynamic-secret-update-aws", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_aws);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateAwsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_azure(configuration: &configuration::Configuration, dynamic_secret_update_azure: models::DynamicSecretUpdateAzure) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateAzureError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_azure = dynamic_secret_update_azure;

    let uri_str = format!("{}/dynamic-secret-update-azure", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_azure);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateAzureError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_cassandra(configuration: &configuration::Configuration, dynamic_secret_update_cassandra: models::DynamicSecretUpdateCassandra) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateCassandraError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_cassandra = dynamic_secret_update_cassandra;

    let uri_str = format!("{}/dynamic-secret-update-cassandra", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_cassandra);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateCassandraError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_custom(configuration: &configuration::Configuration, dynamic_secret_update_custom: Option<models::DynamicSecretUpdateCustom>) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateCustomError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_custom = dynamic_secret_update_custom;

    let uri_str = format!("{}/dynamic-secret-update-custom", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_custom);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateCustomError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_dockerhub(configuration: &configuration::Configuration, dynamic_secret_update_dockerhub: models::DynamicSecretUpdateDockerhub) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateDockerhubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_dockerhub = dynamic_secret_update_dockerhub;

    let uri_str = format!("{}/dynamic-secret-update-dockerhub", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_dockerhub);

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

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateDockerhubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_eks(configuration: &configuration::Configuration, dynamic_secret_update_eks: models::DynamicSecretUpdateEks) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateEksError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_eks = dynamic_secret_update_eks;

    let uri_str = format!("{}/dynamic-secret-update-eks", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_eks);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateEksError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_gcp(configuration: &configuration::Configuration, dynamic_secret_update_gcp: models::DynamicSecretUpdateGcp) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_gcp = dynamic_secret_update_gcp;

    let uri_str = format!("{}/dynamic-secret-update-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_gcp);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_github(configuration: &configuration::Configuration, dynamic_secret_update_github: models::DynamicSecretUpdateGithub) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateGithubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_github = dynamic_secret_update_github;

    let uri_str = format!("{}/dynamic-secret-update-github", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_github);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateGithubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_gitlab(configuration: &configuration::Configuration, dynamic_secret_update_gitlab: models::DynamicSecretUpdateGitlab) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateGitlabError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_gitlab = dynamic_secret_update_gitlab;

    let uri_str = format!("{}/dynamic-secret-update-gitlab", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_gitlab);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateGitlabError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_gke(configuration: &configuration::Configuration, dynamic_secret_update_gke: models::DynamicSecretUpdateGke) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateGkeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_gke = dynamic_secret_update_gke;

    let uri_str = format!("{}/dynamic-secret-update-gke", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_gke);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateGkeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_google_workspace(configuration: &configuration::Configuration, dynamic_secret_update_google_workspace: models::DynamicSecretUpdateGoogleWorkspace) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateGoogleWorkspaceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_google_workspace = dynamic_secret_update_google_workspace;

    let uri_str = format!("{}/dynamic-secret-update-google-workspace", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_google_workspace);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateGoogleWorkspaceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_hana_db(configuration: &configuration::Configuration, dynamic_secret_update_hana_db: models::DynamicSecretUpdateHanaDb) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateHanaDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_hana_db = dynamic_secret_update_hana_db;

    let uri_str = format!("{}/dynamic-secret-update-hana", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_hana_db);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateHanaDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_k8s(configuration: &configuration::Configuration, dynamic_secret_update_k8s: models::DynamicSecretUpdateK8s) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateK8sError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_k8s = dynamic_secret_update_k8s;

    let uri_str = format!("{}/dynamic-secret-update-k8s", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_k8s);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateK8sError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_ldap(configuration: &configuration::Configuration, dynamic_secret_update_ldap: models::DynamicSecretUpdateLdap) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_ldap = dynamic_secret_update_ldap;

    let uri_str = format!("{}/dynamic-secret-update-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_ldap);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_mongo_db(configuration: &configuration::Configuration, dynamic_secret_update_mongo_db: models::DynamicSecretUpdateMongoDb) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateMongoDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_mongo_db = dynamic_secret_update_mongo_db;

    let uri_str = format!("{}/dynamic-secret-update-mongo", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_mongo_db);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateMongoDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_ms_sql(configuration: &configuration::Configuration, dynamic_secret_update_ms_sql: models::DynamicSecretUpdateMsSql) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateMsSqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_ms_sql = dynamic_secret_update_ms_sql;

    let uri_str = format!("{}/dynamic-secret-update-mssql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_ms_sql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateMsSqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_my_sql(configuration: &configuration::Configuration, dynamic_secret_update_my_sql: models::DynamicSecretUpdateMySql) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateMySqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_my_sql = dynamic_secret_update_my_sql;

    let uri_str = format!("{}/dynamic-secret-update-mysql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_my_sql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateMySqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_open_ai(configuration: &configuration::Configuration, dynamic_secret_update_open_ai: models::DynamicSecretUpdateOpenAi) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateOpenAiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_open_ai = dynamic_secret_update_open_ai;

    let uri_str = format!("{}/dynamic-secret-update-openai", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_open_ai);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateOpenAiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_oracle_db(configuration: &configuration::Configuration, dynamic_secret_update_oracle_db: models::DynamicSecretUpdateOracleDb) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateOracleDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_oracle_db = dynamic_secret_update_oracle_db;

    let uri_str = format!("{}/dynamic-secret-update-oracle", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_oracle_db);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateOracleDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_ping(configuration: &configuration::Configuration, dynamic_secret_update_ping: models::DynamicSecretUpdatePing) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdatePingError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_ping = dynamic_secret_update_ping;

    let uri_str = format!("{}/dynamic-secret-update-ping", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_ping);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdatePingError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_postgre_sql(configuration: &configuration::Configuration, dynamic_secret_update_postgre_sql: models::DynamicSecretUpdatePostgreSql) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdatePostgreSqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_postgre_sql = dynamic_secret_update_postgre_sql;

    let uri_str = format!("{}/dynamic-secret-update-postgresql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_postgre_sql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdatePostgreSqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_rabbit_mq(configuration: &configuration::Configuration, dynamic_secret_update_rabbit_mq: models::DynamicSecretUpdateRabbitMq) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateRabbitMqError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_rabbit_mq = dynamic_secret_update_rabbit_mq;

    let uri_str = format!("{}/dynamic-secret-update-rabbitmq", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_rabbit_mq);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateRabbitMqError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_rdp(configuration: &configuration::Configuration, dynamic_secret_update_rdp: models::DynamicSecretUpdateRdp) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateRdpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_rdp = dynamic_secret_update_rdp;

    let uri_str = format!("{}/dynamic-secret-update-rdp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_rdp);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateRdpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_redis(configuration: &configuration::Configuration, dynamic_secret_update_redis: models::DynamicSecretUpdateRedis) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateRedisError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_redis = dynamic_secret_update_redis;

    let uri_str = format!("{}/dynamic-secret-update-redis", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_redis);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateRedisError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_redshift(configuration: &configuration::Configuration, dynamic_secret_update_redshift: models::DynamicSecretUpdateRedshift) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateRedshiftError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_redshift = dynamic_secret_update_redshift;

    let uri_str = format!("{}/dynamic-secret-update-redshift", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_redshift);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateRedshiftError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_snowflake(configuration: &configuration::Configuration, dynamic_secret_update_snowflake: models::DynamicSecretUpdateSnowflake) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateSnowflakeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_snowflake = dynamic_secret_update_snowflake;

    let uri_str = format!("{}/dynamic-secret-update-snowflake", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_snowflake);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateSnowflakeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn dynamic_secret_update_venafi(configuration: &configuration::Configuration, dynamic_secret_update_venafi: models::DynamicSecretUpdateVenafi) -> Result<models::DynamicSecretUpdateOutput, Error<DynamicSecretUpdateVenafiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_dynamic_secret_update_venafi = dynamic_secret_update_venafi;

    let uri_str = format!("{}/dynamic-secret-update-venafi", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_dynamic_secret_update_venafi);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DynamicSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<DynamicSecretUpdateVenafiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn encrypt(configuration: &configuration::Configuration, encrypt: models::Encrypt) -> Result<models::EncryptOutput, Error<EncryptError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_encrypt = encrypt;

    let uri_str = format!("{}/encrypt", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_encrypt);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EncryptOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EncryptOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EncryptError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn encrypt_batch(configuration: &configuration::Configuration, batch_encryption_request_line: Vec<models::BatchEncryptionRequestLine>) -> Result<models::EncryptOutput, Error<EncryptBatchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_batch_encryption_request_line = batch_encryption_request_line;

    let uri_str = format!("{}/encrypt-batch", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_batch_encryption_request_line);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EncryptOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EncryptOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EncryptBatchError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn encrypt_gpg(configuration: &configuration::Configuration, encrypt_gpg: models::EncryptGpg) -> Result<models::EncryptGpgOutput, Error<EncryptGpgError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_encrypt_gpg = encrypt_gpg;

    let uri_str = format!("{}/encrypt-gpg", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_encrypt_gpg);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EncryptGpgOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EncryptGpgOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EncryptGpgError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn encrypt_with_classic_key(configuration: &configuration::Configuration, encrypt_with_classic_key: models::EncryptWithClassicKey) -> Result<models::EncryptOutput, Error<EncryptWithClassicKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_encrypt_with_classic_key = encrypt_with_classic_key;

    let uri_str = format!("{}/encrypt-with-classic-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_encrypt_with_classic_key);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EncryptOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EncryptOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EncryptWithClassicKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn esm_create(configuration: &configuration::Configuration, esm_create: models::EsmCreate) -> Result<models::EsmCreateSecretOutput, Error<EsmCreateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_esm_create = esm_create;

    let uri_str = format!("{}/esm-create", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_esm_create);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EsmCreateSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EsmCreateSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EsmCreateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn esm_delete(configuration: &configuration::Configuration, esm_delete: models::EsmDelete) -> Result<models::EsmDeleteSecretOutput, Error<EsmDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_esm_delete = esm_delete;

    let uri_str = format!("{}/esm-delete", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_esm_delete);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EsmDeleteSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EsmDeleteSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EsmDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn esm_get(configuration: &configuration::Configuration, esm_get: models::EsmGet) -> Result<models::EsmGetSecretOutput, Error<EsmGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_esm_get = esm_get;

    let uri_str = format!("{}/esm-get", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_esm_get);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EsmGetSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EsmGetSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EsmGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn esm_list(configuration: &configuration::Configuration, esm_list: models::EsmList) -> Result<models::EsmListSecretsOutput, Error<EsmListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_esm_list = esm_list;

    let uri_str = format!("{}/esm-list", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_esm_list);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EsmListSecretsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EsmListSecretsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EsmListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn esm_update(configuration: &configuration::Configuration, esm_update: models::EsmUpdate) -> Result<models::EsmUpdateSecretOutput, Error<EsmUpdateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_esm_update = esm_update;

    let uri_str = format!("{}/esm-update", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_esm_update);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EsmUpdateSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EsmUpdateSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EsmUpdateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_action(configuration: &configuration::Configuration, event_action: models::EventAction) -> Result<serde_json::Value, Error<EventActionError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_action = event_action;

    let uri_str = format!("{}/event-action", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_action);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventActionError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_create_email(configuration: &configuration::Configuration, event_forwarder_create_email: models::EventForwarderCreateEmail) -> Result<models::EventForwarderCreateUpdateOutput, Error<EventForwarderCreateEmailError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_create_email = event_forwarder_create_email;

    let uri_str = format!("{}/event-forwarder-create-email", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_create_email);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderCreateEmailError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_create_service_now(configuration: &configuration::Configuration, event_forwarder_create_service_now: models::EventForwarderCreateServiceNow) -> Result<models::EventForwarderCreateUpdateOutput, Error<EventForwarderCreateServiceNowError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_create_service_now = event_forwarder_create_service_now;

    let uri_str = format!("{}/event-forwarder-create-servicenow", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_create_service_now);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderCreateServiceNowError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_create_slack(configuration: &configuration::Configuration, event_forwarder_create_slack: models::EventForwarderCreateSlack) -> Result<models::EventForwarderCreateUpdateOutput, Error<EventForwarderCreateSlackError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_create_slack = event_forwarder_create_slack;

    let uri_str = format!("{}/event-forwarder-create-slack", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_create_slack);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderCreateSlackError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_create_teams(configuration: &configuration::Configuration, event_forwarder_create_teams: models::EventForwarderCreateTeams) -> Result<models::EventForwarderCreateUpdateOutput, Error<EventForwarderCreateTeamsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_create_teams = event_forwarder_create_teams;

    let uri_str = format!("{}/event-forwarder-create-teams", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_create_teams);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderCreateTeamsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_create_webhook(configuration: &configuration::Configuration, event_forwarder_create_webhook: models::EventForwarderCreateWebhook) -> Result<models::EventForwarderCreateUpdateOutput, Error<EventForwarderCreateWebhookError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_create_webhook = event_forwarder_create_webhook;

    let uri_str = format!("{}/event-forwarder-create-webhook", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_create_webhook);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderCreateWebhookError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_delete(configuration: &configuration::Configuration, event_forwarder_delete: models::EventForwarderDelete) -> Result<models::EventForwarderDeleteOutput, Error<EventForwarderDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_delete = event_forwarder_delete;

    let uri_str = format!("{}/event-forwarder-delete", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_delete);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderDeleteOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderDeleteOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_get(configuration: &configuration::Configuration, event_forwarder_get: models::EventForwarderGet) -> Result<models::EventForwarderGetOutput, Error<EventForwarderGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_get = event_forwarder_get;

    let uri_str = format!("{}/event-forwarder-get", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_get);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderGetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderGetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_update_email(configuration: &configuration::Configuration, event_forwarder_update_email: models::EventForwarderUpdateEmail) -> Result<models::EventForwarderCreateUpdateOutput, Error<EventForwarderUpdateEmailError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_update_email = event_forwarder_update_email;

    let uri_str = format!("{}/event-forwarder-update-email", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_update_email);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderUpdateEmailError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_update_service_now(configuration: &configuration::Configuration, event_forwarder_update_service_now: models::EventForwarderUpdateServiceNow) -> Result<models::EventForwarderCreateUpdateOutput, Error<EventForwarderUpdateServiceNowError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_update_service_now = event_forwarder_update_service_now;

    let uri_str = format!("{}/event-forwarder-update-servicenow", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_update_service_now);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderUpdateServiceNowError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_update_slack(configuration: &configuration::Configuration, event_forwarder_update_slack: models::EventForwarderUpdateSlack) -> Result<models::EventForwarderCreateUpdateOutput, Error<EventForwarderUpdateSlackError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_update_slack = event_forwarder_update_slack;

    let uri_str = format!("{}/event-forwarder-update-slack", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_update_slack);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderUpdateSlackError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_update_teams(configuration: &configuration::Configuration, event_forwarder_update_teams: models::EventForwarderUpdateTeams) -> Result<models::EventForwarderCreateUpdateOutput, Error<EventForwarderUpdateTeamsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_update_teams = event_forwarder_update_teams;

    let uri_str = format!("{}/event-forwarder-update-teams", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_update_teams);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderUpdateTeamsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn event_forwarder_update_webhook(configuration: &configuration::Configuration, event_forwarder_update_webhook: models::EventForwarderUpdateWebhook) -> Result<models::EventForwarderCreateUpdateOutput, Error<EventForwarderUpdateWebhookError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_event_forwarder_update_webhook = event_forwarder_update_webhook;

    let uri_str = format!("{}/event-forwarder-update-webhook", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_event_forwarder_update_webhook);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::EventForwarderCreateUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<EventForwarderUpdateWebhookError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn export_classic_key(configuration: &configuration::Configuration, export_classic_key: models::ExportClassicKey) -> Result<models::ExportClassicKeyOutput, Error<ExportClassicKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_export_classic_key = export_classic_key;

    let uri_str = format!("{}/export-classic-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_export_classic_key);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ExportClassicKeyOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ExportClassicKeyOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ExportClassicKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn folder_create(configuration: &configuration::Configuration, folder_create: models::FolderCreate) -> Result<models::FolderCreateOutput, Error<FolderCreateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_folder_create = folder_create;

    let uri_str = format!("{}/folder-create", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_folder_create);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::FolderCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::FolderCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<FolderCreateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn folder_delete(configuration: &configuration::Configuration, folder_delete: models::FolderDelete) -> Result<serde_json::Value, Error<FolderDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_folder_delete = folder_delete;

    let uri_str = format!("{}/folder-delete", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_folder_delete);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<FolderDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn folder_get(configuration: &configuration::Configuration, folder_get: models::FolderGet) -> Result<models::FolderGetOutput, Error<FolderGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_folder_get = folder_get;

    let uri_str = format!("{}/folder-get", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_folder_get);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::FolderGetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::FolderGetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<FolderGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn folder_update(configuration: &configuration::Configuration, folder_update: models::FolderUpdate) -> Result<serde_json::Value, Error<FolderUpdateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_folder_update = folder_update;

    let uri_str = format!("{}/folder-update", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_folder_update);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<FolderUpdateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_allowed_access(configuration: &configuration::Configuration, gateway_create_allowed_access: models::GatewayCreateAllowedAccess) -> Result<models::AllowedAccess, Error<GatewayCreateAllowedAccessError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_allowed_access = gateway_create_allowed_access;

    let uri_str = format!("{}/gateway-create-allowed-access", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_allowed_access);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AllowedAccess`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AllowedAccess`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateAllowedAccessError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_k8_s_auth_config(configuration: &configuration::Configuration, gateway_create_k8_s_auth_config: models::GatewayCreateK8SAuthConfig) -> Result<models::GatewayCreateK8SAuthConfigOutput, Error<GatewayCreateK8SAuthConfigError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_k8_s_auth_config = gateway_create_k8_s_auth_config;

    let uri_str = format!("{}/gateway-create-k8s-auth-config", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_k8_s_auth_config);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateK8SAuthConfigOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateK8SAuthConfigOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateK8SAuthConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_migration(configuration: &configuration::Configuration, gateway_create_migration: models::GatewayCreateMigration) -> Result<models::GatewayMigrationCreateOutput, Error<GatewayCreateMigrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_migration = gateway_create_migration;

    let uri_str = format!("{}/gateway-create-migration", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_migration);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayMigrationCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayMigrationCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateMigrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_artifactory(configuration: &configuration::Configuration, gateway_create_producer_artifactory: models::GatewayCreateProducerArtifactory) -> Result<models::GatewayCreateProducerArtifactoryOutput, Error<GatewayCreateProducerArtifactoryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_artifactory = gateway_create_producer_artifactory;

    let uri_str = format!("{}/gateway-create-producer-artifactory", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_artifactory);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerArtifactoryOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerArtifactoryOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerArtifactoryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_aws(configuration: &configuration::Configuration, gateway_create_producer_aws: models::GatewayCreateProducerAws) -> Result<models::GatewayCreateProducerAwsOutput, Error<GatewayCreateProducerAwsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_aws = gateway_create_producer_aws;

    let uri_str = format!("{}/gateway-create-producer-aws", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_aws);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerAwsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerAwsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerAwsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_azure(configuration: &configuration::Configuration, gateway_create_producer_azure: models::GatewayCreateProducerAzure) -> Result<models::GatewayCreateProducerAzureOutput, Error<GatewayCreateProducerAzureError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_azure = gateway_create_producer_azure;

    let uri_str = format!("{}/gateway-create-producer-azure", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_azure);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerAzureOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerAzureOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerAzureError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_cassandra(configuration: &configuration::Configuration, gateway_create_producer_cassandra: models::GatewayCreateProducerCassandra) -> Result<models::GatewayCreateProducerCassandraOutput, Error<GatewayCreateProducerCassandraError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_cassandra = gateway_create_producer_cassandra;

    let uri_str = format!("{}/gateway-create-producer-cassandra", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_cassandra);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerCassandraOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerCassandraOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerCassandraError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_chef(configuration: &configuration::Configuration, gateway_create_producer_chef: models::GatewayCreateProducerChef) -> Result<models::GatewayCreateProducerChefOutput, Error<GatewayCreateProducerChefError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_chef = gateway_create_producer_chef;

    let uri_str = format!("{}/gateway-create-producer-chef", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_chef);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerChefOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerChefOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerChefError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_custom(configuration: &configuration::Configuration, gateway_create_producer_custom: Option<models::GatewayCreateProducerCustom>) -> Result<models::GatewayCreateProducerCustomOutput, Error<GatewayCreateProducerCustomError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_custom = gateway_create_producer_custom;

    let uri_str = format!("{}/gateway-create-producer-custom", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_custom);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerCustomOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerCustomOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerCustomError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_dockerhub(configuration: &configuration::Configuration, gateway_create_producer_dockerhub: models::GatewayCreateProducerDockerhub) -> Result<models::GatewayCreateProducerDockerhubOutput, Error<GatewayCreateProducerDockerhubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_dockerhub = gateway_create_producer_dockerhub;

    let uri_str = format!("{}/gateway-create-producer-dockerhub", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_dockerhub);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerDockerhubOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerDockerhubOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerDockerhubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_eks(configuration: &configuration::Configuration, gateway_create_producer_eks: models::GatewayCreateProducerEks) -> Result<models::GatewayCreateProducerEksOutput, Error<GatewayCreateProducerEksError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_eks = gateway_create_producer_eks;

    let uri_str = format!("{}/gateway-create-producer-eks", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_eks);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerEksOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerEksOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerEksError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_gcp(configuration: &configuration::Configuration, gateway_create_producer_gcp: models::GatewayCreateProducerGcp) -> Result<models::GatewayCreateProducerGcpOutput, Error<GatewayCreateProducerGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_gcp = gateway_create_producer_gcp;

    let uri_str = format!("{}/gateway-create-producer-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_gcp);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerGcpOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerGcpOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_github(configuration: &configuration::Configuration, gateway_create_producer_github: models::GatewayCreateProducerGithub) -> Result<models::GatewayCreateProducerGithubOutput, Error<GatewayCreateProducerGithubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_github = gateway_create_producer_github;

    let uri_str = format!("{}/gateway-create-producer-github", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_github);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerGithubOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerGithubOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerGithubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_gke(configuration: &configuration::Configuration, gateway_create_producer_gke: models::GatewayCreateProducerGke) -> Result<models::GatewayCreateProducerGkeOutput, Error<GatewayCreateProducerGkeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_gke = gateway_create_producer_gke;

    let uri_str = format!("{}/gateway-create-producer-gke", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_gke);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerGkeOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerGkeOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerGkeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_hana_db(configuration: &configuration::Configuration, gateway_create_producer_hana_db: models::GatewayCreateProducerHanaDb) -> Result<models::GatewayCreateProducerHanaDbOutput, Error<GatewayCreateProducerHanaDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_hana_db = gateway_create_producer_hana_db;

    let uri_str = format!("{}/gateway-create-producer-hanadb", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_hana_db);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerHanaDbOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerHanaDbOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerHanaDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_ldap(configuration: &configuration::Configuration, gateway_create_producer_ldap: models::GatewayCreateProducerLdap) -> Result<models::GatewayCreateProducerLdapOutput, Error<GatewayCreateProducerLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_ldap = gateway_create_producer_ldap;

    let uri_str = format!("{}/gateway-create-producer-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_ldap);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerLdapOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerLdapOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_mongo(configuration: &configuration::Configuration, gateway_create_producer_mongo: models::GatewayCreateProducerMongo) -> Result<models::GatewayCreateProducerMongoOutput, Error<GatewayCreateProducerMongoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_mongo = gateway_create_producer_mongo;

    let uri_str = format!("{}/gateway-create-producer-mongo", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_mongo);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerMongoOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerMongoOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerMongoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_mssql(configuration: &configuration::Configuration, gateway_create_producer_mssql: models::GatewayCreateProducerMssql) -> Result<models::GatewayCreateProducerMssqlOutput, Error<GatewayCreateProducerMssqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_mssql = gateway_create_producer_mssql;

    let uri_str = format!("{}/gateway-create-producer-mssql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_mssql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerMssqlOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerMssqlOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerMssqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_my_sql(configuration: &configuration::Configuration, gateway_create_producer_my_sql: models::GatewayCreateProducerMySql) -> Result<models::GatewayCreateProducerMySqlOutput, Error<GatewayCreateProducerMySqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_my_sql = gateway_create_producer_my_sql;

    let uri_str = format!("{}/gateway-create-producer-mysql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_my_sql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerMySqlOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerMySqlOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerMySqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_native_k8_s(configuration: &configuration::Configuration, gateway_create_producer_native_k8_s: models::GatewayCreateProducerNativeK8S) -> Result<models::GatewayCreateProducerNativeK8SOutput, Error<GatewayCreateProducerNativeK8SError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_native_k8_s = gateway_create_producer_native_k8_s;

    let uri_str = format!("{}/gateway-create-producer-k8s", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_native_k8_s);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerNativeK8SOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerNativeK8SOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerNativeK8SError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_oracle_db(configuration: &configuration::Configuration, gateway_create_producer_oracle_db: models::GatewayCreateProducerOracleDb) -> Result<models::GatewayCreateProducerOracleDbOutput, Error<GatewayCreateProducerOracleDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_oracle_db = gateway_create_producer_oracle_db;

    let uri_str = format!("{}/gateway-create-producer-oracle", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_oracle_db);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerOracleDbOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerOracleDbOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerOracleDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_ping(configuration: &configuration::Configuration, gateway_create_producer_ping: models::GatewayCreateProducerPing) -> Result<models::GatewayCreateProducerPingOutput, Error<GatewayCreateProducerPingError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_ping = gateway_create_producer_ping;

    let uri_str = format!("{}/gateway-create-producer-ping", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_ping);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerPingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerPingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerPingError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_postgre_sql(configuration: &configuration::Configuration, gateway_create_producer_postgre_sql: models::GatewayCreateProducerPostgreSql) -> Result<models::GatewayCreateProducerPostgreSqlOutput, Error<GatewayCreateProducerPostgreSqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_postgre_sql = gateway_create_producer_postgre_sql;

    let uri_str = format!("{}/gateway-create-producer-postgresql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_postgre_sql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerPostgreSqlOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerPostgreSqlOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerPostgreSqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_rabbit_mq(configuration: &configuration::Configuration, gateway_create_producer_rabbit_mq: models::GatewayCreateProducerRabbitMq) -> Result<models::GatewayCreateProducerRabbitMqOutput, Error<GatewayCreateProducerRabbitMqError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_rabbit_mq = gateway_create_producer_rabbit_mq;

    let uri_str = format!("{}/gateway-create-producer-rabbitmq", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_rabbit_mq);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerRabbitMqOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerRabbitMqOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerRabbitMqError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_rdp(configuration: &configuration::Configuration, gateway_create_producer_rdp: models::GatewayCreateProducerRdp) -> Result<models::GatewayCreateProducerRdpOutput, Error<GatewayCreateProducerRdpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_rdp = gateway_create_producer_rdp;

    let uri_str = format!("{}/gateway-create-producer-rdp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_rdp);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerRdpOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerRdpOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerRdpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_redis(configuration: &configuration::Configuration, gateway_create_producer_redis: models::GatewayCreateProducerRedis) -> Result<models::GatewayCreateProducerRedisOutput, Error<GatewayCreateProducerRedisError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_redis = gateway_create_producer_redis;

    let uri_str = format!("{}/gateway-create-producer-Redis", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_redis);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerRedisOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerRedisOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerRedisError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_redshift(configuration: &configuration::Configuration, gateway_create_producer_redshift: models::GatewayCreateProducerRedshift) -> Result<models::GatewayCreateProducerRedshiftOutput, Error<GatewayCreateProducerRedshiftError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_redshift = gateway_create_producer_redshift;

    let uri_str = format!("{}/gateway-create-producer-redshift", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_redshift);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerRedshiftOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerRedshiftOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerRedshiftError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_snowflake(configuration: &configuration::Configuration, gateway_create_producer_snowflake: models::GatewayCreateProducerSnowflake) -> Result<models::GatewayCreateProducerSnowflakeOutput, Error<GatewayCreateProducerSnowflakeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_snowflake = gateway_create_producer_snowflake;

    let uri_str = format!("{}/gateway-create-producer-snowflake", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_snowflake);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerSnowflakeOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerSnowflakeOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerSnowflakeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_create_producer_venafi(configuration: &configuration::Configuration, gateway_create_producer_venafi: models::GatewayCreateProducerVenafi) -> Result<models::GatewayCreateProducerVenafiOutput, Error<GatewayCreateProducerVenafiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_create_producer_venafi = gateway_create_producer_venafi;

    let uri_str = format!("{}/gateway-create-producer-certificate-automation", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_create_producer_venafi);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayCreateProducerVenafiOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayCreateProducerVenafiOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayCreateProducerVenafiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_delete_allowed_access(configuration: &configuration::Configuration, gateway_delete_allowed_access: models::GatewayDeleteAllowedAccess) -> Result<models::GatewayDeleteAllowedAccessOutput, Error<GatewayDeleteAllowedAccessError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_delete_allowed_access = gateway_delete_allowed_access;

    let uri_str = format!("{}/gateway-delete-allowed-access", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_delete_allowed_access);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayDeleteAllowedAccessOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayDeleteAllowedAccessOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayDeleteAllowedAccessError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_delete_k8_s_auth_config(configuration: &configuration::Configuration, gateway_delete_k8_s_auth_config: models::GatewayDeleteK8SAuthConfig) -> Result<models::GatewayDeleteK8SAuthConfigOutput, Error<GatewayDeleteK8SAuthConfigError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_delete_k8_s_auth_config = gateway_delete_k8_s_auth_config;

    let uri_str = format!("{}/gateway-delete-k8s-auth-config", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_delete_k8_s_auth_config);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayDeleteK8SAuthConfigOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayDeleteK8SAuthConfigOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayDeleteK8SAuthConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_delete_migration(configuration: &configuration::Configuration, gateway_delete_migration: models::GatewayDeleteMigration) -> Result<models::GatewayMigrationDeleteOutput, Error<GatewayDeleteMigrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_delete_migration = gateway_delete_migration;

    let uri_str = format!("{}/gateway-delete-migration", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_delete_migration);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayMigrationDeleteOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayMigrationDeleteOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayDeleteMigrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_delete_producer(configuration: &configuration::Configuration, gateway_delete_producer: models::GatewayDeleteProducer) -> Result<models::GatewayDeleteProducerOutput, Error<GatewayDeleteProducerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_delete_producer = gateway_delete_producer;

    let uri_str = format!("{}/gateway-delete-producer", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_delete_producer);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayDeleteProducerOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayDeleteProducerOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayDeleteProducerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_download_customer_fragments(configuration: &configuration::Configuration, gateway_download_customer_fragments: models::GatewayDownloadCustomerFragments) -> Result<models::GatewayDownloadCustomerFragmentsOutput, Error<GatewayDownloadCustomerFragmentsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_download_customer_fragments = gateway_download_customer_fragments;

    let uri_str = format!("{}/gateway-download-customer-fragments", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_download_customer_fragments);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayDownloadCustomerFragmentsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayDownloadCustomerFragmentsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayDownloadCustomerFragmentsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_get_allowed_access(configuration: &configuration::Configuration, gateway_get_allowed_access: models::GatewayGetAllowedAccess) -> Result<models::AllowedAccess, Error<GatewayGetAllowedAccessError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_get_allowed_access = gateway_get_allowed_access;

    let uri_str = format!("{}/gateway-get-allowed-access", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_get_allowed_access);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AllowedAccess`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AllowedAccess`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayGetAllowedAccessError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_get_cache(configuration: &configuration::Configuration, gateway_get_cache: models::GatewayGetCache) -> Result<models::CacheConfigPart, Error<GatewayGetCacheError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_get_cache = gateway_get_cache;

    let uri_str = format!("{}/gateway-get-cache", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_get_cache);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::CacheConfigPart`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::CacheConfigPart`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayGetCacheError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_get_config(configuration: &configuration::Configuration, gateway_get_config: models::GatewayGetConfig) -> Result<models::AkeylessGatewayConfig, Error<GatewayGetConfigError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_get_config = gateway_get_config;

    let uri_str = format!("{}/gateway-get-config", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_get_config);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AkeylessGatewayConfig`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AkeylessGatewayConfig`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayGetConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_get_defaults(configuration: &configuration::Configuration, gateway_get_defaults: models::GatewayGetDefaults) -> Result<models::GatewayGetDefaultsOutput, Error<GatewayGetDefaultsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_get_defaults = gateway_get_defaults;

    let uri_str = format!("{}/gateway-get-defaults", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_get_defaults);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayGetDefaultsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayGetDefaultsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayGetDefaultsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_get_k8_s_auth_config(configuration: &configuration::Configuration, gateway_get_k8_s_auth_config: models::GatewayGetK8SAuthConfig) -> Result<models::GatewayGetK8SAuthConfigOutput, Error<GatewayGetK8SAuthConfigError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_get_k8_s_auth_config = gateway_get_k8_s_auth_config;

    let uri_str = format!("{}/gateway-get-k8s-auth-config", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_get_k8_s_auth_config);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayGetK8SAuthConfigOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayGetK8SAuthConfigOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayGetK8SAuthConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_get_ldap_auth_config(configuration: &configuration::Configuration, gateway_get_ldap_auth_config: models::GatewayGetLdapAuthConfig) -> Result<models::GatewayGetLdapAuthConfigOutput, Error<GatewayGetLdapAuthConfigError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_get_ldap_auth_config = gateway_get_ldap_auth_config;

    let uri_str = format!("{}/gateway-get-ldap-auth-config", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_get_ldap_auth_config);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayGetLdapAuthConfigOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayGetLdapAuthConfigOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayGetLdapAuthConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_get_log_forwarding(configuration: &configuration::Configuration, gateway_get_log_forwarding: models::GatewayGetLogForwarding) -> Result<models::LogForwardingConfigPart, Error<GatewayGetLogForwardingError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_get_log_forwarding = gateway_get_log_forwarding;

    let uri_str = format!("{}/gateway-get-log-forwarding", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_get_log_forwarding);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::LogForwardingConfigPart`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::LogForwardingConfigPart`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayGetLogForwardingError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_get_migration(configuration: &configuration::Configuration, gateway_get_migration: models::GatewayGetMigration) -> Result<models::GatewayMigrationGetOutput, Error<GatewayGetMigrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_get_migration = gateway_get_migration;

    let uri_str = format!("{}/gateway-get-migration", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_get_migration);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayMigrationGetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayMigrationGetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayGetMigrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_get_producer(configuration: &configuration::Configuration, gateway_get_producer: models::GatewayGetProducer) -> Result<models::DsProducerDetails, Error<GatewayGetProducerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_get_producer = gateway_get_producer;

    let uri_str = format!("{}/gateway-get-producer", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_get_producer);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DsProducerDetails`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DsProducerDetails`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayGetProducerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_get_remote_access(configuration: &configuration::Configuration, gateway_get_remote_access: models::GatewayGetRemoteAccess) -> Result<models::BastionConfigReplyObj, Error<GatewayGetRemoteAccessError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_get_remote_access = gateway_get_remote_access;

    let uri_str = format!("{}/gateway-get-remote-access", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_get_remote_access);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::BastionConfigReplyObj`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::BastionConfigReplyObj`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayGetRemoteAccessError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_get_tmp_users(configuration: &configuration::Configuration, gateway_get_tmp_users: models::GatewayGetTmpUsers) -> Result<Vec<models::TmpUserData>, Error<GatewayGetTmpUsersError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_get_tmp_users = gateway_get_tmp_users;

    let uri_str = format!("{}/gateway-get-producer-tmp-creds", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_get_tmp_users);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;models::TmpUserData&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;models::TmpUserData&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayGetTmpUsersError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_list_customer_fragments(configuration: &configuration::Configuration, gateway_list_customer_fragments: models::GatewayListCustomerFragments) -> Result<std::collections::HashMap<String, serde_json::Value>, Error<GatewayListCustomerFragmentsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_list_customer_fragments = gateway_list_customer_fragments;

    let uri_str = format!("{}/gateway-list-customer-fragments", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_list_customer_fragments);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap&lt;String, serde_json::Value&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap&lt;String, serde_json::Value&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayListCustomerFragmentsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_list_migration(configuration: &configuration::Configuration, gateway_list_migration: models::GatewayListMigration) -> Result<models::GatewayMigrationListOutput, Error<GatewayListMigrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_list_migration = gateway_list_migration;

    let uri_str = format!("{}/gateway-list-migration", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_list_migration);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayMigrationListOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayMigrationListOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayListMigrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_list_producers(configuration: &configuration::Configuration, gateway_list_producers: models::GatewayListProducers) -> Result<models::GetProducersListReplyObj, Error<GatewayListProducersError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_list_producers = gateway_list_producers;

    let uri_str = format!("{}/gateway-list-producers", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_list_producers);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetProducersListReplyObj`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetProducersListReplyObj`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayListProducersError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_list_rotated_secrets(configuration: &configuration::Configuration, gateway_list_rotated_secrets: models::GatewayListRotatedSecrets) -> Result<models::ListItemsOutput, Error<GatewayListRotatedSecretsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_list_rotated_secrets = gateway_list_rotated_secrets;

    let uri_str = format!("{}/gateway-list-rotated-secrets", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_list_rotated_secrets);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListItemsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListItemsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayListRotatedSecretsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_migrate_personal_items(configuration: &configuration::Configuration, gateway_migrate_personal_items: Option<models::GatewayMigratePersonalItems>) -> Result<models::GatewayMigratePersonalItemsOutput, Error<GatewayMigratePersonalItemsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_migrate_personal_items = gateway_migrate_personal_items;

    let uri_str = format!("{}/gateway-migrate-personal-items", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_migrate_personal_items);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayMigratePersonalItemsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayMigratePersonalItemsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayMigratePersonalItemsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_revoke_tmp_users(configuration: &configuration::Configuration, gateway_revoke_tmp_users: models::GatewayRevokeTmpUsers) -> Result<(), Error<GatewayRevokeTmpUsersError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_revoke_tmp_users = gateway_revoke_tmp_users;

    let uri_str = format!("{}/gateway-revoke-producer-tmp-creds", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_revoke_tmp_users);

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayRevokeTmpUsersError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_start_producer(configuration: &configuration::Configuration, gateway_start_producer: models::GatewayStartProducer) -> Result<models::GatewayStartProducerOutput, Error<GatewayStartProducerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_start_producer = gateway_start_producer;

    let uri_str = format!("{}/gateway-start-producer", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_start_producer);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayStartProducerOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayStartProducerOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayStartProducerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_status_migration(configuration: &configuration::Configuration, gateway_status_migration: models::GatewayStatusMigration) -> Result<models::MigrationStatusReplyObj, Error<GatewayStatusMigrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_status_migration = gateway_status_migration;

    let uri_str = format!("{}/gateway-migration-status", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_status_migration);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::MigrationStatusReplyObj`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::MigrationStatusReplyObj`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayStatusMigrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_stop_producer(configuration: &configuration::Configuration, gateway_stop_producer: models::GatewayStopProducer) -> Result<models::GatewayStopProducerOutput, Error<GatewayStopProducerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_stop_producer = gateway_stop_producer;

    let uri_str = format!("{}/gateway-stop-producer", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_stop_producer);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayStopProducerOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayStopProducerOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayStopProducerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_sync_migration(configuration: &configuration::Configuration, gateway_sync_migration: models::GatewaySyncMigration) -> Result<models::GatewayMigrationSyncOutput, Error<GatewaySyncMigrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_sync_migration = gateway_sync_migration;

    let uri_str = format!("{}/gateway-sync-migration", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_sync_migration);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayMigrationSyncOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayMigrationSyncOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewaySyncMigrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_allowed_access(configuration: &configuration::Configuration, gateway_update_allowed_access: models::GatewayUpdateAllowedAccess) -> Result<models::AllowedAccess, Error<GatewayUpdateAllowedAccessError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_allowed_access = gateway_update_allowed_access;

    let uri_str = format!("{}/gateway-update-allowed-access", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_allowed_access);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AllowedAccess`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AllowedAccess`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateAllowedAccessError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_cache(configuration: &configuration::Configuration, gateway_update_cache: models::GatewayUpdateCache) -> Result<models::GatewayUpdateOutput, Error<GatewayUpdateCacheError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_cache = gateway_update_cache;

    let uri_str = format!("{}/gateway-update-cache", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_cache);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateCacheError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_defaults(configuration: &configuration::Configuration, gateway_update_defaults: models::GatewayUpdateDefaults) -> Result<models::GatewayUpdateOutput, Error<GatewayUpdateDefaultsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_defaults = gateway_update_defaults;

    let uri_str = format!("{}/gateway-update-defaults", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_defaults);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateDefaultsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_item(configuration: &configuration::Configuration, gateway_update_item: models::GatewayUpdateItem) -> Result<models::GatewayUpdateItemOutput, Error<GatewayUpdateItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_item = gateway_update_item;

    let uri_str = format!("{}/gateway-update-item", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_item);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateItemOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateItemOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateItemError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_k8_s_auth_config(configuration: &configuration::Configuration, gateway_update_k8_s_auth_config: models::GatewayUpdateK8SAuthConfig) -> Result<models::GatewayUpdateK8SAuthConfigOutput, Error<GatewayUpdateK8SAuthConfigError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_k8_s_auth_config = gateway_update_k8_s_auth_config;

    let uri_str = format!("{}/gateway-update-k8s-auth-config", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_k8_s_auth_config);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateK8SAuthConfigOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateK8SAuthConfigOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateK8SAuthConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_ldap_auth_config(configuration: &configuration::Configuration, gateway_update_ldap_auth_config: models::GatewayUpdateLdapAuthConfig) -> Result<models::GatewayUpdateLdapAuthConfigOutput, Error<GatewayUpdateLdapAuthConfigError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_ldap_auth_config = gateway_update_ldap_auth_config;

    let uri_str = format!("{}/gateway-update-ldap-auth-config", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_ldap_auth_config);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLdapAuthConfigOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLdapAuthConfigOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLdapAuthConfigError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_log_forwarding_aws_s3(configuration: &configuration::Configuration, gateway_update_log_forwarding_aws_s3: models::GatewayUpdateLogForwardingAwsS3) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GatewayUpdateLogForwardingAwsS3Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_log_forwarding_aws_s3 = gateway_update_log_forwarding_aws_s3;

    let uri_str = format!("{}/gateway-update-log-forwarding-aws-s3", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_log_forwarding_aws_s3);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLogForwardingAwsS3Error> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_log_forwarding_azure_analytics(configuration: &configuration::Configuration, gateway_update_log_forwarding_azure_analytics: models::GatewayUpdateLogForwardingAzureAnalytics) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GatewayUpdateLogForwardingAzureAnalyticsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_log_forwarding_azure_analytics = gateway_update_log_forwarding_azure_analytics;

    let uri_str = format!("{}/gateway-update-log-forwarding-azure-analytics", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_log_forwarding_azure_analytics);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLogForwardingAzureAnalyticsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_log_forwarding_datadog(configuration: &configuration::Configuration, gateway_update_log_forwarding_datadog: models::GatewayUpdateLogForwardingDatadog) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GatewayUpdateLogForwardingDatadogError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_log_forwarding_datadog = gateway_update_log_forwarding_datadog;

    let uri_str = format!("{}/gateway-update-log-forwarding-datadog", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_log_forwarding_datadog);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLogForwardingDatadogError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_log_forwarding_elasticsearch(configuration: &configuration::Configuration, gateway_update_log_forwarding_elasticsearch: models::GatewayUpdateLogForwardingElasticsearch) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GatewayUpdateLogForwardingElasticsearchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_log_forwarding_elasticsearch = gateway_update_log_forwarding_elasticsearch;

    let uri_str = format!("{}/gateway-update-log-forwarding-elasticsearch", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_log_forwarding_elasticsearch);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLogForwardingElasticsearchError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_log_forwarding_google_chronicle(configuration: &configuration::Configuration, gateway_update_log_forwarding_google_chronicle: models::GatewayUpdateLogForwardingGoogleChronicle) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GatewayUpdateLogForwardingGoogleChronicleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_log_forwarding_google_chronicle = gateway_update_log_forwarding_google_chronicle;

    let uri_str = format!("{}/gateway-update-log-forwarding-google-chronicle", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_log_forwarding_google_chronicle);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLogForwardingGoogleChronicleError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_log_forwarding_logstash(configuration: &configuration::Configuration, gateway_update_log_forwarding_logstash: models::GatewayUpdateLogForwardingLogstash) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GatewayUpdateLogForwardingLogstashError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_log_forwarding_logstash = gateway_update_log_forwarding_logstash;

    let uri_str = format!("{}/gateway-update-log-forwarding-logstash", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_log_forwarding_logstash);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLogForwardingLogstashError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_log_forwarding_logz_io(configuration: &configuration::Configuration, gateway_update_log_forwarding_logz_io: models::GatewayUpdateLogForwardingLogzIo) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GatewayUpdateLogForwardingLogzIoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_log_forwarding_logz_io = gateway_update_log_forwarding_logz_io;

    let uri_str = format!("{}/gateway-update-log-forwarding-logz-io", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_log_forwarding_logz_io);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLogForwardingLogzIoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_log_forwarding_splunk(configuration: &configuration::Configuration, gateway_update_log_forwarding_splunk: models::GatewayUpdateLogForwardingSplunk) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GatewayUpdateLogForwardingSplunkError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_log_forwarding_splunk = gateway_update_log_forwarding_splunk;

    let uri_str = format!("{}/gateway-update-log-forwarding-splunk", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_log_forwarding_splunk);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLogForwardingSplunkError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_log_forwarding_stdout(configuration: &configuration::Configuration, gateway_update_log_forwarding_stdout: models::GatewayUpdateLogForwardingStdout) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GatewayUpdateLogForwardingStdoutError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_log_forwarding_stdout = gateway_update_log_forwarding_stdout;

    let uri_str = format!("{}/gateway-update-log-forwarding-stdout", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_log_forwarding_stdout);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLogForwardingStdoutError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_log_forwarding_sumologic(configuration: &configuration::Configuration, gateway_update_log_forwarding_sumologic: models::GatewayUpdateLogForwardingSumologic) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GatewayUpdateLogForwardingSumologicError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_log_forwarding_sumologic = gateway_update_log_forwarding_sumologic;

    let uri_str = format!("{}/gateway-update-log-forwarding-sumologic", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_log_forwarding_sumologic);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLogForwardingSumologicError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_log_forwarding_syslog(configuration: &configuration::Configuration, gateway_update_log_forwarding_syslog: models::GatewayUpdateLogForwardingSyslog) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GatewayUpdateLogForwardingSyslogError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_log_forwarding_syslog = gateway_update_log_forwarding_syslog;

    let uri_str = format!("{}/gateway-update-log-forwarding-syslog", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_log_forwarding_syslog);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateLogForwardingSyslogError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_migration(configuration: &configuration::Configuration, gateway_update_migration: models::GatewayUpdateMigration) -> Result<models::GatewayMigrationUpdateOutput, Error<GatewayUpdateMigrationError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_migration = gateway_update_migration;

    let uri_str = format!("{}/gateway-update-migration", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_migration);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayMigrationUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayMigrationUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateMigrationError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_artifactory(configuration: &configuration::Configuration, gateway_update_producer_artifactory: models::GatewayUpdateProducerArtifactory) -> Result<models::GatewayUpdateProducerArtifactoryOutput, Error<GatewayUpdateProducerArtifactoryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_artifactory = gateway_update_producer_artifactory;

    let uri_str = format!("{}/gateway-update-producer-artifactory", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_artifactory);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerArtifactoryOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerArtifactoryOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerArtifactoryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_aws(configuration: &configuration::Configuration, gateway_update_producer_aws: models::GatewayUpdateProducerAws) -> Result<models::GatewayUpdateProducerAwsOutput, Error<GatewayUpdateProducerAwsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_aws = gateway_update_producer_aws;

    let uri_str = format!("{}/gateway-update-producer-aws", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_aws);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerAwsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerAwsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerAwsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_azure(configuration: &configuration::Configuration, gateway_update_producer_azure: models::GatewayUpdateProducerAzure) -> Result<models::GatewayUpdateProducerAzureOutput, Error<GatewayUpdateProducerAzureError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_azure = gateway_update_producer_azure;

    let uri_str = format!("{}/gateway-update-producer-azure", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_azure);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerAzureOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerAzureOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerAzureError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_cassandra(configuration: &configuration::Configuration, gateway_update_producer_cassandra: models::GatewayUpdateProducerCassandra) -> Result<models::GatewayUpdateProducerCassandraOutput, Error<GatewayUpdateProducerCassandraError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_cassandra = gateway_update_producer_cassandra;

    let uri_str = format!("{}/gateway-update-producer-cassandra", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_cassandra);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerCassandraOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerCassandraOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerCassandraError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_chef(configuration: &configuration::Configuration, gateway_update_producer_chef: models::GatewayUpdateProducerChef) -> Result<models::GatewayUpdateProducerChefOutput, Error<GatewayUpdateProducerChefError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_chef = gateway_update_producer_chef;

    let uri_str = format!("{}/gateway-update-producer-chef", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_chef);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerChefOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerChefOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerChefError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_custom(configuration: &configuration::Configuration, gateway_update_producer_custom: Option<models::GatewayUpdateProducerCustom>) -> Result<models::GatewayUpdateProducerCustomOutput, Error<GatewayUpdateProducerCustomError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_custom = gateway_update_producer_custom;

    let uri_str = format!("{}/gateway-update-producer-custom", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_custom);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerCustomOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerCustomOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerCustomError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_dockerhub(configuration: &configuration::Configuration, gateway_update_producer_dockerhub: models::GatewayUpdateProducerDockerhub) -> Result<models::GatewayUpdateProducerDockerhubOutput, Error<GatewayUpdateProducerDockerhubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_dockerhub = gateway_update_producer_dockerhub;

    let uri_str = format!("{}/gateway-update-producer-dockerhub", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_dockerhub);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerDockerhubOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerDockerhubOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerDockerhubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_eks(configuration: &configuration::Configuration, gateway_update_producer_eks: models::GatewayUpdateProducerEks) -> Result<models::GatewayUpdateProducerEksOutput, Error<GatewayUpdateProducerEksError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_eks = gateway_update_producer_eks;

    let uri_str = format!("{}/gateway-update-producer-eks", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_eks);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerEksOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerEksOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerEksError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_gcp(configuration: &configuration::Configuration, gateway_update_producer_gcp: models::GatewayUpdateProducerGcp) -> Result<models::GatewayUpdateProducerGcpOutput, Error<GatewayUpdateProducerGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_gcp = gateway_update_producer_gcp;

    let uri_str = format!("{}/gateway-update-producer-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_gcp);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerGcpOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerGcpOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_github(configuration: &configuration::Configuration, gateway_update_producer_github: models::GatewayUpdateProducerGithub) -> Result<models::GatewayUpdateProducerGithubOutput, Error<GatewayUpdateProducerGithubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_github = gateway_update_producer_github;

    let uri_str = format!("{}/gateway-update-producer-github", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_github);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerGithubOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerGithubOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerGithubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_gke(configuration: &configuration::Configuration, gateway_update_producer_gke: models::GatewayUpdateProducerGke) -> Result<models::GatewayUpdateProducerGkeOutput, Error<GatewayUpdateProducerGkeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_gke = gateway_update_producer_gke;

    let uri_str = format!("{}/gateway-update-producer-gke", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_gke);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerGkeOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerGkeOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerGkeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_hana_db(configuration: &configuration::Configuration, gateway_update_producer_hana_db: models::GatewayUpdateProducerHanaDb) -> Result<models::GatewayUpdateProducerHanaDbOutput, Error<GatewayUpdateProducerHanaDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_hana_db = gateway_update_producer_hana_db;

    let uri_str = format!("{}/gateway-update-producer-hana", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_hana_db);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerHanaDbOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerHanaDbOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerHanaDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_ldap(configuration: &configuration::Configuration, gateway_update_producer_ldap: models::GatewayUpdateProducerLdap) -> Result<models::GatewayUpdateProducerLdapOutput, Error<GatewayUpdateProducerLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_ldap = gateway_update_producer_ldap;

    let uri_str = format!("{}/gateway-update-producer-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_ldap);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerLdapOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerLdapOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_mongo(configuration: &configuration::Configuration, gateway_update_producer_mongo: models::GatewayUpdateProducerMongo) -> Result<models::GatewayUpdateProducerMongoOutput, Error<GatewayUpdateProducerMongoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_mongo = gateway_update_producer_mongo;

    let uri_str = format!("{}/gateway-update-producer-mongo", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_mongo);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerMongoOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerMongoOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerMongoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_mssql(configuration: &configuration::Configuration, gateway_update_producer_mssql: models::GatewayUpdateProducerMssql) -> Result<models::GatewayUpdateProducerMssqlOutput, Error<GatewayUpdateProducerMssqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_mssql = gateway_update_producer_mssql;

    let uri_str = format!("{}/gateway-update-producer-mssql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_mssql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerMssqlOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerMssqlOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerMssqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_my_sql(configuration: &configuration::Configuration, gateway_update_producer_my_sql: models::GatewayUpdateProducerMySql) -> Result<models::GatewayUpdateProducerMySqlOutput, Error<GatewayUpdateProducerMySqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_my_sql = gateway_update_producer_my_sql;

    let uri_str = format!("{}/gateway-update-producer-mysql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_my_sql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerMySqlOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerMySqlOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerMySqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_native_k8_s(configuration: &configuration::Configuration, gateway_update_producer_native_k8_s: models::GatewayUpdateProducerNativeK8S) -> Result<models::GatewayUpdateProducerNativeK8SOutput, Error<GatewayUpdateProducerNativeK8SError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_native_k8_s = gateway_update_producer_native_k8_s;

    let uri_str = format!("{}/gateway-update-producer-k8s", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_native_k8_s);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerNativeK8SOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerNativeK8SOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerNativeK8SError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_oracle_db(configuration: &configuration::Configuration, gateway_update_producer_oracle_db: models::GatewayUpdateProducerOracleDb) -> Result<models::GatewayUpdateProducerOracleDbOutput, Error<GatewayUpdateProducerOracleDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_oracle_db = gateway_update_producer_oracle_db;

    let uri_str = format!("{}/gateway-update-producer-oracle", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_oracle_db);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerOracleDbOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerOracleDbOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerOracleDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_ping(configuration: &configuration::Configuration, gateway_update_producer_ping: models::GatewayUpdateProducerPing) -> Result<models::GatewayUpdateProducerPingOutput, Error<GatewayUpdateProducerPingError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_ping = gateway_update_producer_ping;

    let uri_str = format!("{}/gateway-update-producer-ping", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_ping);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerPingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerPingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerPingError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_postgre_sql(configuration: &configuration::Configuration, gateway_update_producer_postgre_sql: models::GatewayUpdateProducerPostgreSql) -> Result<models::GatewayUpdateProducerPostgreSqlOutput, Error<GatewayUpdateProducerPostgreSqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_postgre_sql = gateway_update_producer_postgre_sql;

    let uri_str = format!("{}/gateway-update-producer-postgresql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_postgre_sql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerPostgreSqlOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerPostgreSqlOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerPostgreSqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_rabbit_mq(configuration: &configuration::Configuration, gateway_update_producer_rabbit_mq: models::GatewayUpdateProducerRabbitMq) -> Result<models::GatewayUpdateProducerRabbitMqOutput, Error<GatewayUpdateProducerRabbitMqError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_rabbit_mq = gateway_update_producer_rabbit_mq;

    let uri_str = format!("{}/gateway-update-producer-rabbitmq", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_rabbit_mq);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerRabbitMqOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerRabbitMqOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerRabbitMqError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_rdp(configuration: &configuration::Configuration, gateway_update_producer_rdp: models::GatewayUpdateProducerRdp) -> Result<models::GatewayUpdateProducerRdpOutput, Error<GatewayUpdateProducerRdpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_rdp = gateway_update_producer_rdp;

    let uri_str = format!("{}/gateway-update-producer-rdp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_rdp);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerRdpOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerRdpOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerRdpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_redis(configuration: &configuration::Configuration, gateway_update_producer_redis: models::GatewayUpdateProducerRedis) -> Result<models::GatewayUpdateProducerRedisOutput, Error<GatewayUpdateProducerRedisError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_redis = gateway_update_producer_redis;

    let uri_str = format!("{}/gateway-update-producer-redis", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_redis);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerRedisOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerRedisOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerRedisError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_redshift(configuration: &configuration::Configuration, gateway_update_producer_redshift: models::GatewayUpdateProducerRedshift) -> Result<models::GatewayUpdateProducerRedshiftOutput, Error<GatewayUpdateProducerRedshiftError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_redshift = gateway_update_producer_redshift;

    let uri_str = format!("{}/gateway-update-producer-redshift", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_redshift);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerRedshiftOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerRedshiftOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerRedshiftError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_snowflake(configuration: &configuration::Configuration, gateway_update_producer_snowflake: models::GatewayUpdateProducerSnowflake) -> Result<models::GatewayUpdateProducerSnowflakeOutput, Error<GatewayUpdateProducerSnowflakeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_snowflake = gateway_update_producer_snowflake;

    let uri_str = format!("{}/gateway-update-producer-snowflake", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_snowflake);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerSnowflakeOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerSnowflakeOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerSnowflakeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_producer_venafi(configuration: &configuration::Configuration, gateway_update_producer_venafi: models::GatewayUpdateProducerVenafi) -> Result<models::GatewayUpdateProducerVenafiOutput, Error<GatewayUpdateProducerVenafiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_producer_venafi = gateway_update_producer_venafi;

    let uri_str = format!("{}/gateway-update-producer-certificate-automation", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_producer_venafi);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateProducerVenafiOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateProducerVenafiOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateProducerVenafiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_remote_access(configuration: &configuration::Configuration, gateway_update_remote_access: models::GatewayUpdateRemoteAccess) -> Result<serde_json::Value, Error<GatewayUpdateRemoteAccessError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_remote_access = gateway_update_remote_access;

    let uri_str = format!("{}/gateway-update-remote-access", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_remote_access);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateRemoteAccessError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_remote_access_desktop_app(configuration: &configuration::Configuration, gateway_update_remote_access_desktop_app: models::GatewayUpdateRemoteAccessDesktopApp) -> Result<serde_json::Value, Error<GatewayUpdateRemoteAccessDesktopAppError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_remote_access_desktop_app = gateway_update_remote_access_desktop_app;

    let uri_str = format!("{}/gateway-update-remote-access-desktop-app", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_remote_access_desktop_app);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateRemoteAccessDesktopAppError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_remote_access_rdp_recordings(configuration: &configuration::Configuration, gateway_update_remote_access_rdp_recordings: models::GatewayUpdateRemoteAccessRdpRecordings) -> Result<serde_json::Value, Error<GatewayUpdateRemoteAccessRdpRecordingsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_remote_access_rdp_recordings = gateway_update_remote_access_rdp_recordings;

    let uri_str = format!("{}/gateway-update-remote-access-rdp-recording", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_remote_access_rdp_recordings);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateRemoteAccessRdpRecordingsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_tls_cert(configuration: &configuration::Configuration, gateway_update_tls_cert: models::GatewayUpdateTlsCert) -> Result<models::GatewayUpdateTlsCertOutput, Error<GatewayUpdateTlsCertError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_tls_cert = gateway_update_tls_cert;

    let uri_str = format!("{}/gateway-update-tls-cert", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_tls_cert);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateTlsCertOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateTlsCertOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateTlsCertError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gateway_update_tmp_users(configuration: &configuration::Configuration, gateway_update_tmp_users: models::GatewayUpdateTmpUsers) -> Result<(), Error<GatewayUpdateTmpUsersError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gateway_update_tmp_users = gateway_update_tmp_users;

    let uri_str = format!("{}/gateway-update-producer-tmp-creds", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gateway_update_tmp_users);

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<GatewayUpdateTmpUsersError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn generate_acme_eab(configuration: &configuration::Configuration, generate_acme_eab: models::GenerateAcmeEab) -> Result<models::GenerateAcmeEabOutput, Error<GenerateAcmeEabError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_generate_acme_eab = generate_acme_eab;

    let uri_str = format!("{}/generate-acme-eab", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_generate_acme_eab);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GenerateAcmeEabOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GenerateAcmeEabOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GenerateAcmeEabError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn generate_ca(configuration: &configuration::Configuration, generate_ca: models::GenerateCa) -> Result<models::GenerateCaOutput, Error<GenerateCaError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_generate_ca = generate_ca;

    let uri_str = format!("{}/generate-ca", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_generate_ca);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GenerateCaOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GenerateCaOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GenerateCaError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn generate_csr(configuration: &configuration::Configuration, generate_csr: models::GenerateCsr) -> Result<models::GenerateCsrOutput, Error<GenerateCsrError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_generate_csr = generate_csr;

    let uri_str = format!("{}/generate-csr", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_generate_csr);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GenerateCsrOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GenerateCsrOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GenerateCsrError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_account_logo(configuration: &configuration::Configuration, ) -> Result<std::collections::HashMap<String, String>, Error<GetAccountLogoError>> {

    let uri_str = format!("{}/get-account-logo", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap&lt;String, String&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap&lt;String, String&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAccountLogoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_account_settings(configuration: &configuration::Configuration, get_account_settings: models::GetAccountSettings) -> Result<models::GetAccountSettingsCommandOutput, Error<GetAccountSettingsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_account_settings = get_account_settings;

    let uri_str = format!("{}/get-account-settings", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_account_settings);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetAccountSettingsCommandOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetAccountSettingsCommandOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAccountSettingsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_analytics_data(configuration: &configuration::Configuration, get_analytics_data: models::GetAnalyticsData) -> Result<models::AllAnalyticsData, Error<GetAnalyticsDataError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_analytics_data = get_analytics_data;

    let uri_str = format!("{}/get-analytics-data", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_analytics_data);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AllAnalyticsData`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AllAnalyticsData`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAnalyticsDataError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_auth_method(configuration: &configuration::Configuration, get_auth_method: models::GetAuthMethod) -> Result<models::AuthMethod, Error<GetAuthMethodError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_auth_method = get_auth_method;

    let uri_str = format!("{}/get-auth-method", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_auth_method);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::AuthMethod`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::AuthMethod`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetAuthMethodError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_cert_challenge(configuration: &configuration::Configuration, get_cert_challenge: models::GetCertChallenge) -> Result<models::GetCertChallengeOutput, Error<GetCertChallengeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_cert_challenge = get_cert_challenge;

    let uri_str = format!("{}/get-cert-challenge", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_cert_challenge);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetCertChallengeOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetCertChallengeOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCertChallengeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_certificate_value(configuration: &configuration::Configuration, get_certificate_value: models::GetCertificateValue) -> Result<models::GetCertificateValueOutput, Error<GetCertificateValueError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_certificate_value = get_certificate_value;

    let uri_str = format!("{}/get-certificate-value", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_certificate_value);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetCertificateValueOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetCertificateValueOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetCertificateValueError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_dynamic_secret_value(configuration: &configuration::Configuration, get_dynamic_secret_value: models::GetDynamicSecretValue) -> Result<serde_json::Value, Error<GetDynamicSecretValueError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_dynamic_secret_value = get_dynamic_secret_value;

    let uri_str = format!("{}/get-dynamic-secret-value", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_dynamic_secret_value);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetDynamicSecretValueError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_event_forwarder(configuration: &configuration::Configuration, get_event_forwarder: models::GetEventForwarder) -> Result<models::GetEventForwarderOutput, Error<GetEventForwarderError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_event_forwarder = get_event_forwarder;

    let uri_str = format!("{}/get-event-forwarder", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_event_forwarder);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetEventForwarderOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetEventForwarderOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetEventForwarderError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_group(configuration: &configuration::Configuration, get_group: models::GetGroup) -> Result<models::GetGroupOutput, Error<GetGroupError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_group = get_group;

    let uri_str = format!("{}/get-group", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_group);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetGroupOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetGroupOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetGroupError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_kube_exec_creds(configuration: &configuration::Configuration, get_kube_exec_creds: models::GetKubeExecCreds) -> Result<models::GetKubeExecCredsOutput, Error<GetKubeExecCredsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_kube_exec_creds = get_kube_exec_creds;

    let uri_str = format!("{}/get-kube-exec-creds", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_kube_exec_creds);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetKubeExecCredsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetKubeExecCredsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetKubeExecCredsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_last_user_event_status(configuration: &configuration::Configuration, get_last_user_event_status: models::GetLastUserEventStatus) -> Result<models::GetUserEventStatusOutput, Error<GetLastUserEventStatusError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_last_user_event_status = get_last_user_event_status;

    let uri_str = format!("{}/user-event-last-status", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_last_user_event_status);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetUserEventStatusOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetUserEventStatusOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetLastUserEventStatusError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_pki_certificate(configuration: &configuration::Configuration, get_pki_certificate: models::GetPkiCertificate) -> Result<models::GetPkiCertificateOutput, Error<GetPkiCertificateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_pki_certificate = get_pki_certificate;

    let uri_str = format!("{}/get-pki-certificate", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_pki_certificate);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetPkiCertificateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetPkiCertificateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetPkiCertificateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_role(configuration: &configuration::Configuration, get_role: models::GetRole) -> Result<models::Role, Error<GetRoleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_role = get_role;

    let uri_str = format!("{}/get-role", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_role);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Role`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Role`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRoleError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_rotated_secret_value(configuration: &configuration::Configuration, get_rotated_secret_value: models::GetRotatedSecretValue) -> Result<serde_json::Value, Error<GetRotatedSecretValueError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_rotated_secret_value = get_rotated_secret_value;

    let uri_str = format!("{}/get-rotated-secret-value", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_rotated_secret_value);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRotatedSecretValueError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_rsa_public(configuration: &configuration::Configuration, get_rsa_public: models::GetRsaPublic) -> Result<models::GetRsaPublicOutput, Error<GetRsaPublicError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_rsa_public = get_rsa_public;

    let uri_str = format!("{}/get-rsa-public", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_rsa_public);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetRsaPublicOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetRsaPublicOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetRsaPublicError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_secret_value(configuration: &configuration::Configuration, get_secret_value: models::GetSecretValue) -> Result<serde_json::Value, Error<GetSecretValueError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_secret_value = get_secret_value;

    let uri_str = format!("{}/get-secret-value", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_secret_value);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSecretValueError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_ssh_certificate(configuration: &configuration::Configuration, get_ssh_certificate: models::GetSshCertificate) -> Result<models::GetSshCertificateOutput, Error<GetSshCertificateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_ssh_certificate = get_ssh_certificate;

    let uri_str = format!("{}/get-ssh-certificate", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_ssh_certificate);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetSshCertificateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetSshCertificateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetSshCertificateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_tags(configuration: &configuration::Configuration, get_tags: models::GetTags) -> Result<Vec<String>, Error<GetTagsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_tags = get_tags;

    let uri_str = format!("{}/get-tags", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_tags);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `Vec&lt;String&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `Vec&lt;String&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetTagsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_target(configuration: &configuration::Configuration, get_target: models::GetTarget) -> Result<models::Target, Error<GetTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_target = get_target;

    let uri_str = format!("{}/get-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Target`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Target`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn get_target_details(configuration: &configuration::Configuration, get_target_details: models::GetTargetDetails) -> Result<models::GetTargetDetailsOutput, Error<GetTargetDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_get_target_details = get_target_details;

    let uri_str = format!("{}/get-target-details", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_get_target_details);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetTargetDetailsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetTargetDetailsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GetTargetDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gw_update_remote_access_session_logs_aws_s3(configuration: &configuration::Configuration, gw_update_remote_access_session_logs_aws_s3: models::GwUpdateRemoteAccessSessionLogsAwsS3) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GwUpdateRemoteAccessSessionLogsAwsS3Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gw_update_remote_access_session_logs_aws_s3 = gw_update_remote_access_session_logs_aws_s3;

    let uri_str = format!("{}/gateway-update-remote-access-session-forwarding-aws-s3", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gw_update_remote_access_session_logs_aws_s3);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GwUpdateRemoteAccessSessionLogsAwsS3Error> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gw_update_remote_access_session_logs_azure_analytics(configuration: &configuration::Configuration, gw_update_remote_access_session_logs_azure_analytics: models::GwUpdateRemoteAccessSessionLogsAzureAnalytics) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GwUpdateRemoteAccessSessionLogsAzureAnalyticsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gw_update_remote_access_session_logs_azure_analytics = gw_update_remote_access_session_logs_azure_analytics;

    let uri_str = format!("{}/gateway-update-remote-access-session-forwarding-azure-analytics", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gw_update_remote_access_session_logs_azure_analytics);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GwUpdateRemoteAccessSessionLogsAzureAnalyticsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gw_update_remote_access_session_logs_datadog(configuration: &configuration::Configuration, gw_update_remote_access_session_logs_datadog: models::GwUpdateRemoteAccessSessionLogsDatadog) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GwUpdateRemoteAccessSessionLogsDatadogError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gw_update_remote_access_session_logs_datadog = gw_update_remote_access_session_logs_datadog;

    let uri_str = format!("{}/gateway-update-remote-access-session-forwarding-datadog", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gw_update_remote_access_session_logs_datadog);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GwUpdateRemoteAccessSessionLogsDatadogError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gw_update_remote_access_session_logs_elasticsearch(configuration: &configuration::Configuration, gw_update_remote_access_session_logs_elasticsearch: models::GwUpdateRemoteAccessSessionLogsElasticsearch) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GwUpdateRemoteAccessSessionLogsElasticsearchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gw_update_remote_access_session_logs_elasticsearch = gw_update_remote_access_session_logs_elasticsearch;

    let uri_str = format!("{}/gateway-update-remote-access-session-forwarding-elasticsearch", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gw_update_remote_access_session_logs_elasticsearch);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GwUpdateRemoteAccessSessionLogsElasticsearchError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gw_update_remote_access_session_logs_google_chronicle(configuration: &configuration::Configuration, gw_update_remote_access_session_logs_google_chronicle: models::GwUpdateRemoteAccessSessionLogsGoogleChronicle) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GwUpdateRemoteAccessSessionLogsGoogleChronicleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gw_update_remote_access_session_logs_google_chronicle = gw_update_remote_access_session_logs_google_chronicle;

    let uri_str = format!("{}/gateway-update-remote-access-session-forwarding-google-chronicle", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gw_update_remote_access_session_logs_google_chronicle);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GwUpdateRemoteAccessSessionLogsGoogleChronicleError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gw_update_remote_access_session_logs_logstash(configuration: &configuration::Configuration, gw_update_remote_access_session_logs_logstash: models::GwUpdateRemoteAccessSessionLogsLogstash) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GwUpdateRemoteAccessSessionLogsLogstashError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gw_update_remote_access_session_logs_logstash = gw_update_remote_access_session_logs_logstash;

    let uri_str = format!("{}/gateway-update-remote-access-session-forwarding-logstash", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gw_update_remote_access_session_logs_logstash);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GwUpdateRemoteAccessSessionLogsLogstashError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gw_update_remote_access_session_logs_logz_io(configuration: &configuration::Configuration, gw_update_remote_access_session_logs_logz_io: models::GwUpdateRemoteAccessSessionLogsLogzIo) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GwUpdateRemoteAccessSessionLogsLogzIoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gw_update_remote_access_session_logs_logz_io = gw_update_remote_access_session_logs_logz_io;

    let uri_str = format!("{}/gateway-update-remote-access-session-forwarding-logz-io", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gw_update_remote_access_session_logs_logz_io);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GwUpdateRemoteAccessSessionLogsLogzIoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gw_update_remote_access_session_logs_splunk(configuration: &configuration::Configuration, gw_update_remote_access_session_logs_splunk: models::GwUpdateRemoteAccessSessionLogsSplunk) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GwUpdateRemoteAccessSessionLogsSplunkError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gw_update_remote_access_session_logs_splunk = gw_update_remote_access_session_logs_splunk;

    let uri_str = format!("{}/gateway-update-remote-access-session-forwarding-splunk", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gw_update_remote_access_session_logs_splunk);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GwUpdateRemoteAccessSessionLogsSplunkError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gw_update_remote_access_session_logs_stdout(configuration: &configuration::Configuration, gw_update_remote_access_session_logs_stdout: models::GwUpdateRemoteAccessSessionLogsStdout) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GwUpdateRemoteAccessSessionLogsStdoutError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gw_update_remote_access_session_logs_stdout = gw_update_remote_access_session_logs_stdout;

    let uri_str = format!("{}/gateway-update-remote-access-session-forwarding-stdout", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gw_update_remote_access_session_logs_stdout);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GwUpdateRemoteAccessSessionLogsStdoutError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gw_update_remote_access_session_logs_sumologic(configuration: &configuration::Configuration, gw_update_remote_access_session_logs_sumologic: models::GwUpdateRemoteAccessSessionLogsSumologic) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GwUpdateRemoteAccessSessionLogsSumologicError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gw_update_remote_access_session_logs_sumologic = gw_update_remote_access_session_logs_sumologic;

    let uri_str = format!("{}/gateway-update-remote-access-session-forwarding-sumologic", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gw_update_remote_access_session_logs_sumologic);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GwUpdateRemoteAccessSessionLogsSumologicError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn gw_update_remote_access_session_logs_syslog(configuration: &configuration::Configuration, gw_update_remote_access_session_logs_syslog: models::GwUpdateRemoteAccessSessionLogsSyslog) -> Result<models::GatewayUpdateLogForwardingOutput, Error<GwUpdateRemoteAccessSessionLogsSyslogError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_gw_update_remote_access_session_logs_syslog = gw_update_remote_access_session_logs_syslog;

    let uri_str = format!("{}/gateway-update-remote-access-session-forwarding-syslog", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_gw_update_remote_access_session_logs_syslog);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewayUpdateLogForwardingOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<GwUpdateRemoteAccessSessionLogsSyslogError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn hmac(configuration: &configuration::Configuration, hmac: models::Hmac) -> Result<models::HmacOutput, Error<HmacError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_hmac = hmac;

    let uri_str = format!("{}/hmac", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_hmac);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::HmacOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::HmacOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<HmacError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn import_passwords(configuration: &configuration::Configuration, import_passwords: models::ImportPasswords) -> Result<models::ImportPasswordsOutput, Error<ImportPasswordsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_import_passwords = import_passwords;

    let uri_str = format!("{}/import-passwords", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_import_passwords);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ImportPasswordsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ImportPasswordsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ImportPasswordsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_client_delete_rule(configuration: &configuration::Configuration, kmip_client_delete_rule: Option<models::KmipClientDeleteRule>) -> Result<models::KmipClientUpdateResponse, Error<KmipClientDeleteRuleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_client_delete_rule = kmip_client_delete_rule;

    let uri_str = format!("{}/kmip-client-delete-rule", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_client_delete_rule);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KmipClientUpdateResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KmipClientUpdateResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipClientDeleteRuleError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_client_set_rule(configuration: &configuration::Configuration, kmip_client_set_rule: Option<models::KmipClientSetRule>) -> Result<models::KmipClientUpdateResponse, Error<KmipClientSetRuleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_client_set_rule = kmip_client_set_rule;

    let uri_str = format!("{}/kmip-client-set-rule", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_client_set_rule);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KmipClientUpdateResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KmipClientUpdateResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipClientSetRuleError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_create_client(configuration: &configuration::Configuration, kmip_create_client: Option<models::KmipCreateClient>) -> Result<models::KmipCreateClientOutput, Error<KmipCreateClientError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_create_client = kmip_create_client;

    let uri_str = format!("{}/kmip-create-client", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_create_client);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KmipCreateClientOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KmipCreateClientOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipCreateClientError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_delete_client(configuration: &configuration::Configuration, kmip_delete_client: Option<models::KmipDeleteClient>) -> Result<serde_json::Value, Error<KmipDeleteClientError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_delete_client = kmip_delete_client;

    let uri_str = format!("{}/kmip-delete-client", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_delete_client);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipDeleteClientError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_delete_server(configuration: &configuration::Configuration, kmip_delete_server: Option<models::KmipDeleteServer>) -> Result<serde_json::Value, Error<KmipDeleteServerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_delete_server = kmip_delete_server;

    let uri_str = format!("{}/kmip-delete-environment", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_delete_server);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipDeleteServerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_describe_client(configuration: &configuration::Configuration, kmip_describe_client: Option<models::KmipDescribeClient>) -> Result<models::KmipClientGetResponse, Error<KmipDescribeClientError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_describe_client = kmip_describe_client;

    let uri_str = format!("{}/kmip-get-client", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_describe_client);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KmipClientGetResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KmipClientGetResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipDescribeClientError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_describe_server(configuration: &configuration::Configuration, kmip_describe_server: Option<models::KmipDescribeServer>) -> Result<models::KmipDescribeServerOutput, Error<KmipDescribeServerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_describe_server = kmip_describe_server;

    let uri_str = format!("{}/kmip-get-environment", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_describe_server);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KmipDescribeServerOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KmipDescribeServerOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipDescribeServerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_list_clients(configuration: &configuration::Configuration, kmip_list_clients: Option<models::KmipListClients>) -> Result<models::KmipClientListResponse, Error<KmipListClientsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_list_clients = kmip_list_clients;

    let uri_str = format!("{}/kmip-list-clients", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_list_clients);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KmipClientListResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KmipClientListResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipListClientsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_move_server(configuration: &configuration::Configuration, kmip_move_server: Option<models::KmipMoveServer>) -> Result<models::KmipMoveServerOutput, Error<KmipMoveServerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_move_server = kmip_move_server;

    let uri_str = format!("{}/kmip-move-environment", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_move_server);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KmipMoveServerOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KmipMoveServerOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipMoveServerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_renew_client_certificate(configuration: &configuration::Configuration, kmip_renew_client_certificate: Option<models::KmipRenewClientCertificate>) -> Result<models::KmipRenewClientCertificateOutput, Error<KmipRenewClientCertificateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_renew_client_certificate = kmip_renew_client_certificate;

    let uri_str = format!("{}/kmip-renew-client", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_renew_client_certificate);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KmipRenewClientCertificateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KmipRenewClientCertificateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipRenewClientCertificateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_renew_server_certificate(configuration: &configuration::Configuration, kmip_renew_server_certificate: Option<models::KmipRenewServerCertificate>) -> Result<models::KmipRenewServerCertificateOutput, Error<KmipRenewServerCertificateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_renew_server_certificate = kmip_renew_server_certificate;

    let uri_str = format!("{}/kmip-renew-environment", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_renew_server_certificate);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KmipRenewServerCertificateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KmipRenewServerCertificateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipRenewServerCertificateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_server_setup(configuration: &configuration::Configuration, kmip_server_setup: Option<models::KmipServerSetup>) -> Result<models::KmipEnvironmentCreateResponse, Error<KmipServerSetupError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_server_setup = kmip_server_setup;

    let uri_str = format!("{}/kmip-create-environment", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_server_setup);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KmipEnvironmentCreateResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KmipEnvironmentCreateResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipServerSetupError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kmip_set_server_state(configuration: &configuration::Configuration, kmip_set_server_state: Option<models::KmipSetServerState>) -> Result<models::KmipSetServerStateOutput, Error<KmipSetServerStateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_kmip_set_server_state = kmip_set_server_state;

    let uri_str = format!("{}/kmip-set-environment-state", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_kmip_set_server_state);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KmipSetServerStateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KmipSetServerStateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KmipSetServerStateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn kubeconfig_generate(configuration: &configuration::Configuration, ) -> Result<models::KubeconfigGenerateOutput, Error<KubeconfigGenerateError>> {

    let uri_str = format!("{}/kubeconfig-generate", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::KubeconfigGenerateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::KubeconfigGenerateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<KubeconfigGenerateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn list_acme_accounts(configuration: &configuration::Configuration, list_acme_accounts: models::ListAcmeAccounts) -> Result<models::ListAcmeAccountsOutput, Error<ListAcmeAccountsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_list_acme_accounts = list_acme_accounts;

    let uri_str = format!("{}/list-acme-accounts", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_list_acme_accounts);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListAcmeAccountsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListAcmeAccountsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListAcmeAccountsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn list_auth_methods(configuration: &configuration::Configuration, list_auth_methods: models::ListAuthMethods) -> Result<models::ListAuthMethodsOutput, Error<ListAuthMethodsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_list_auth_methods = list_auth_methods;

    let uri_str = format!("{}/list-auth-methods", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_list_auth_methods);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListAuthMethodsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListAuthMethodsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListAuthMethodsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn list_gateways(configuration: &configuration::Configuration, list_gateways: models::ListGateways) -> Result<models::GatewaysListResponse, Error<ListGatewaysError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_list_gateways = list_gateways;

    let uri_str = format!("{}/list-gateways", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_list_gateways);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GatewaysListResponse`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GatewaysListResponse`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListGatewaysError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn list_groups(configuration: &configuration::Configuration, list_groups: models::ListGroups) -> Result<models::ListGroupsOutput, Error<ListGroupsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_list_groups = list_groups;

    let uri_str = format!("{}/list-group", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_list_groups);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListGroupsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListGroupsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListGroupsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn list_items(configuration: &configuration::Configuration, list_items: models::ListItems) -> Result<models::ListItemsInPathOutput, Error<ListItemsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_list_items = list_items;

    let uri_str = format!("{}/list-items", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_list_items);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListItemsInPathOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListItemsInPathOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListItemsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn list_roles(configuration: &configuration::Configuration, list_roles: models::ListRoles) -> Result<models::ListRolesOutput, Error<ListRolesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_list_roles = list_roles;

    let uri_str = format!("{}/list-roles", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_list_roles);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListRolesOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListRolesOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListRolesError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn list_shared_items(configuration: &configuration::Configuration, list_shared_items: models::ListSharedItems) -> Result<(), Error<ListSharedItemsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_list_shared_items = list_shared_items;

    let uri_str = format!("{}/list-shared-items", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_list_shared_items);

    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() {
        Ok(())
    } else {
        let content = resp.text().await?;
        let entity: Option<ListSharedItemsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn list_sra_bastions(configuration: &configuration::Configuration, list_sra_bastions: models::ListSraBastions) -> Result<models::BastionsList, Error<ListSraBastionsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_list_sra_bastions = list_sra_bastions;

    let uri_str = format!("{}/list-sra-bastions", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_list_sra_bastions);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::BastionsList`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::BastionsList`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListSraBastionsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn list_sra_sessions(configuration: &configuration::Configuration, list_sra_sessions: models::ListSraSessions) -> Result<models::ListSraSessionsOutput, Error<ListSraSessionsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_list_sra_sessions = list_sra_sessions;

    let uri_str = format!("{}/list-sra-sessions", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_list_sra_sessions);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListSraSessionsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListSraSessionsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListSraSessionsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn list_targets(configuration: &configuration::Configuration, list_targets: models::ListTargets) -> Result<models::ListTargetsOutput, Error<ListTargetsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_list_targets = list_targets;

    let uri_str = format!("{}/list-targets", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_list_targets);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTargetsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTargetsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ListTargetsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn move_objects(configuration: &configuration::Configuration, move_objects: models::MoveObjects) -> Result<serde_json::Value, Error<MoveObjectsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_move_objects = move_objects;

    let uri_str = format!("{}/move-objects", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_move_objects);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<MoveObjectsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn policies_delete(configuration: &configuration::Configuration, policies_delete: models::PoliciesDelete) -> Result<serde_json::Value, Error<PoliciesDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_policies_delete = policies_delete;

    let uri_str = format!("{}/policy-delete", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_policies_delete);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PoliciesDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn policies_get(configuration: &configuration::Configuration, policies_get: models::PoliciesGet) -> Result<models::PoliciesGetOutput, Error<PoliciesGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_policies_get = policies_get;

    let uri_str = format!("{}/policy-get", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_policies_get);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PoliciesGetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::PoliciesGetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PoliciesGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn policies_list(configuration: &configuration::Configuration, policies_list: models::PoliciesList) -> Result<models::PoliciesListOutput, Error<PoliciesListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_policies_list = policies_list;

    let uri_str = format!("{}/policy-list", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_policies_list);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PoliciesListOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::PoliciesListOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PoliciesListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn policy_create_keys(configuration: &configuration::Configuration, policy_create_keys: models::PolicyCreateKeys) -> Result<models::PoliciesCreateOutput, Error<PolicyCreateKeysError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_policy_create_keys = policy_create_keys;

    let uri_str = format!("{}/policy-create-keys", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_policy_create_keys);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::PoliciesCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::PoliciesCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PolicyCreateKeysError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn policy_update_keys(configuration: &configuration::Configuration, policy_update_keys: models::PolicyUpdateKeys) -> Result<serde_json::Value, Error<PolicyUpdateKeysError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_policy_update_keys = policy_update_keys;

    let uri_str = format!("{}/policy-update-keys", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_policy_update_keys);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<PolicyUpdateKeysError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn provision_certificate(configuration: &configuration::Configuration, provision_certificate: models::ProvisionCertificate) -> Result<models::ProvisionCertificateOutput, Error<ProvisionCertificateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_provision_certificate = provision_certificate;

    let uri_str = format!("{}/provision-certificate", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_provision_certificate);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ProvisionCertificateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ProvisionCertificateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ProvisionCertificateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn raw_creds(configuration: &configuration::Configuration, raw_creds: Option<models::RawCreds>) -> Result<models::SystemAccessCredentialsReplyObj, Error<RawCredsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_raw_creds = raw_creds;

    let uri_str = format!("{}/raw-creds", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_raw_creds);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SystemAccessCredentialsReplyObj`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SystemAccessCredentialsReplyObj`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RawCredsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn refresh_key(configuration: &configuration::Configuration, refresh_key: models::RefreshKey) -> Result<models::RefreshKeyOutput, Error<RefreshKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_refresh_key = refresh_key;

    let uri_str = format!("{}/refresh-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_refresh_key);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RefreshKeyOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RefreshKeyOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RefreshKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn renew_certificate(configuration: &configuration::Configuration, renew_certificate: models::RenewCertificate) -> Result<models::RenewCertificateOutput, Error<RenewCertificateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_renew_certificate = renew_certificate;

    let uri_str = format!("{}/renew-certificate", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_renew_certificate);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RenewCertificateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RenewCertificateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RenewCertificateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn request_access(configuration: &configuration::Configuration, request_access: models::RequestAccess) -> Result<models::RequestAccessOutput, Error<RequestAccessError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_request_access = request_access;

    let uri_str = format!("{}/request-access", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_request_access);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RequestAccessOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RequestAccessOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RequestAccessError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn reset_access_key(configuration: &configuration::Configuration, reset_access_key: models::ResetAccessKey) -> Result<models::ResetAuthMethodAccessKeyOutput, Error<ResetAccessKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_reset_access_key = reset_access_key;

    let uri_str = format!("{}/reset-access-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_reset_access_key);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ResetAuthMethodAccessKeyOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ResetAuthMethodAccessKeyOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ResetAccessKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn reverse_rbac(configuration: &configuration::Configuration, reverse_rbac: models::ReverseRbac) -> Result<models::ReverseRbacOutput, Error<ReverseRbacError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_reverse_rbac = reverse_rbac;

    let uri_str = format!("{}/reverse-rbac", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_reverse_rbac);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ReverseRbacOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ReverseRbacOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ReverseRbacError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn revoke_certificate(configuration: &configuration::Configuration, revoke_certificate: models::RevokeCertificate) -> Result<serde_json::Value, Error<RevokeCertificateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_revoke_certificate = revoke_certificate;

    let uri_str = format!("{}/revoke-certificate", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_revoke_certificate);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RevokeCertificateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn revoke_creds(configuration: &configuration::Configuration, ) -> Result<serde_json::Value, Error<RevokeCredsError>> {

    let uri_str = format!("{}/revoke-creds", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RevokeCredsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rollback_secret(configuration: &configuration::Configuration, rollback_secret: models::RollbackSecret) -> Result<models::RollbackSecretOutput, Error<RollbackSecretError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rollback_secret = rollback_secret;

    let uri_str = format!("{}/rollback-secret", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rollback_secret);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RollbackSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RollbackSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RollbackSecretError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotate_key(configuration: &configuration::Configuration, rotate_key: models::RotateKey) -> Result<models::RotateKeyOutput, Error<RotateKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotate_key = rotate_key;

    let uri_str = format!("{}/rotate-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotate_key);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotateKeyOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotateKeyOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotateKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotate_oidc_client_secret(configuration: &configuration::Configuration, rotate_oidc_client_secret: models::RotateOidcClientSecret) -> Result<models::RotateOidcClientOutput, Error<RotateOidcClientSecretError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotate_oidc_client_secret = rotate_oidc_client_secret;

    let uri_str = format!("{}/rotate-oidc-client-secret", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotate_oidc_client_secret);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotateOidcClientOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotateOidcClientOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotateOidcClientSecretError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotate_secret(configuration: &configuration::Configuration, rotate_secret: models::RotateSecret) -> Result<models::RotatedSecretOutput, Error<RotateSecretError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotate_secret = rotate_secret;

    let uri_str = format!("{}/gateway-rotate-secret", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotate_secret);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotateSecretError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_aws(configuration: &configuration::Configuration, rotated_secret_create_aws: models::RotatedSecretCreateAws) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateAwsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_aws = rotated_secret_create_aws;

    let uri_str = format!("{}/rotated-secret-create-aws", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_aws);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateAwsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_azure(configuration: &configuration::Configuration, rotated_secret_create_azure: models::RotatedSecretCreateAzure) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateAzureError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_azure = rotated_secret_create_azure;

    let uri_str = format!("{}/rotated-secret-create-azure", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_azure);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateAzureError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_cassandra(configuration: &configuration::Configuration, rotated_secret_create_cassandra: models::RotatedSecretCreateCassandra) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateCassandraError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_cassandra = rotated_secret_create_cassandra;

    let uri_str = format!("{}/rotated-secret-create-cassandra", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_cassandra);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateCassandraError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_custom(configuration: &configuration::Configuration, rotated_secret_create_custom: models::RotatedSecretCreateCustom) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateCustomError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_custom = rotated_secret_create_custom;

    let uri_str = format!("{}/rotated-secret-create-custom", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_custom);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateCustomError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_dockerhub(configuration: &configuration::Configuration, rotated_secret_create_dockerhub: models::RotatedSecretCreateDockerhub) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateDockerhubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_dockerhub = rotated_secret_create_dockerhub;

    let uri_str = format!("{}/rotated-secret-create-dockerhub", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_dockerhub);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateDockerhubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_gcp(configuration: &configuration::Configuration, rotated_secret_create_gcp: models::RotatedSecretCreateGcp) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_gcp = rotated_secret_create_gcp;

    let uri_str = format!("{}/rotated-secret-create-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_gcp);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_hanadb(configuration: &configuration::Configuration, rotated_secret_create_hanadb: models::RotatedSecretCreateHanadb) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateHanadbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_hanadb = rotated_secret_create_hanadb;

    let uri_str = format!("{}/rotated-secret-create-hanadb", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_hanadb);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateHanadbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_ldap(configuration: &configuration::Configuration, rotated_secret_create_ldap: models::RotatedSecretCreateLdap) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_ldap = rotated_secret_create_ldap;

    let uri_str = format!("{}/rotated-secret-create-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_ldap);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_mongodb(configuration: &configuration::Configuration, rotated_secret_create_mongodb: models::RotatedSecretCreateMongodb) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateMongodbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_mongodb = rotated_secret_create_mongodb;

    let uri_str = format!("{}/rotated-secret-create-mongodb", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_mongodb);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateMongodbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_mssql(configuration: &configuration::Configuration, rotated_secret_create_mssql: models::RotatedSecretCreateMssql) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateMssqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_mssql = rotated_secret_create_mssql;

    let uri_str = format!("{}/rotated-secret-create-mssql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_mssql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateMssqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_mysql(configuration: &configuration::Configuration, rotated_secret_create_mysql: models::RotatedSecretCreateMysql) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateMysqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_mysql = rotated_secret_create_mysql;

    let uri_str = format!("{}/rotated-secret-create-mysql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_mysql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateMysqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_open_ai(configuration: &configuration::Configuration, rotated_secret_create_open_ai: models::RotatedSecretCreateOpenAi) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateOpenAiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_open_ai = rotated_secret_create_open_ai;

    let uri_str = format!("{}/rotated-secret-create-openai", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_open_ai);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateOpenAiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_oracledb(configuration: &configuration::Configuration, rotated_secret_create_oracledb: models::RotatedSecretCreateOracledb) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateOracledbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_oracledb = rotated_secret_create_oracledb;

    let uri_str = format!("{}/rotated-secret-create-oracledb", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_oracledb);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateOracledbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_postgresql(configuration: &configuration::Configuration, rotated_secret_create_postgresql: models::RotatedSecretCreatePostgresql) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreatePostgresqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_postgresql = rotated_secret_create_postgresql;

    let uri_str = format!("{}/rotated-secret-create-postgresql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_postgresql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreatePostgresqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_redis(configuration: &configuration::Configuration, rotated_secret_create_redis: models::RotatedSecretCreateRedis) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateRedisError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_redis = rotated_secret_create_redis;

    let uri_str = format!("{}/rotated-secret-create-redis", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_redis);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateRedisError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_redshift(configuration: &configuration::Configuration, rotated_secret_create_redshift: models::RotatedSecretCreateRedshift) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateRedshiftError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_redshift = rotated_secret_create_redshift;

    let uri_str = format!("{}/rotated-secret-create-redshift", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_redshift);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateRedshiftError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_snowflake(configuration: &configuration::Configuration, rotated_secret_create_snowflake: models::RotatedSecretCreateSnowflake) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateSnowflakeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_snowflake = rotated_secret_create_snowflake;

    let uri_str = format!("{}/rotated-secret-create-snowflake", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_snowflake);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateSnowflakeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_splunk(configuration: &configuration::Configuration, rotated_secret_create_splunk: models::RotatedSecretCreateSplunk) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateSplunkError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_splunk = rotated_secret_create_splunk;

    let uri_str = format!("{}/rotated-secret-create-splunk", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_splunk);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateSplunkError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_ssh(configuration: &configuration::Configuration, rotated_secret_create_ssh: models::RotatedSecretCreateSsh) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateSshError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_ssh = rotated_secret_create_ssh;

    let uri_str = format!("{}/rotated-secret-create-ssh", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_ssh);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateSshError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_create_windows(configuration: &configuration::Configuration, rotated_secret_create_windows: models::RotatedSecretCreateWindows) -> Result<models::RotatedSecretCreateOutput, Error<RotatedSecretCreateWindowsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_create_windows = rotated_secret_create_windows;

    let uri_str = format!("{}/rotated-secret-create-windows", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_create_windows);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretCreateWindowsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_delete(configuration: &configuration::Configuration, rotated_secret_delete: models::RotatedSecretDelete) -> Result<models::DeleteItemOutput, Error<RotatedSecretDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_delete = rotated_secret_delete;

    let uri_str = format!("{}/rotated-secret-delete", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_delete);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::DeleteItemOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::DeleteItemOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_delete_sync(configuration: &configuration::Configuration, rotated_secret_delete_sync: models::RotatedSecretDeleteSync) -> Result<models::RotatedSecretDeleteSyncOutput, Error<RotatedSecretDeleteSyncError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_delete_sync = rotated_secret_delete_sync;

    let uri_str = format!("{}/rotated-secret-delete-sync", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_delete_sync);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretDeleteSyncOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretDeleteSyncOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretDeleteSyncError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_get_value(configuration: &configuration::Configuration, rotated_secret_get_value: models::RotatedSecretGetValue) -> Result<std::collections::HashMap<String, serde_json::Value>, Error<RotatedSecretGetValueError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_get_value = rotated_secret_get_value;

    let uri_str = format!("{}/rotated-secret-get-value", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_get_value);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `std::collections::HashMap&lt;String, serde_json::Value&gt;`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `std::collections::HashMap&lt;String, serde_json::Value&gt;`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretGetValueError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_list(configuration: &configuration::Configuration, rotated_secret_list: models::RotatedSecretList) -> Result<models::GetProducersListReplyObj, Error<RotatedSecretListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_list = rotated_secret_list;

    let uri_str = format!("{}/rotated-secret-list", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_list);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetProducersListReplyObj`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetProducersListReplyObj`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_sync(configuration: &configuration::Configuration, rotated_secret_sync: models::RotatedSecretSync) -> Result<serde_json::Value, Error<RotatedSecretSyncError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_sync = rotated_secret_sync;

    let uri_str = format!("{}/rotated-secret-sync", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_sync);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretSyncError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_aws(configuration: &configuration::Configuration, rotated_secret_update_aws: models::RotatedSecretUpdateAws) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateAwsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_aws = rotated_secret_update_aws;

    let uri_str = format!("{}/rotated-secret-update-aws", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_aws);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateAwsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_azure(configuration: &configuration::Configuration, rotated_secret_update_azure: models::RotatedSecretUpdateAzure) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateAzureError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_azure = rotated_secret_update_azure;

    let uri_str = format!("{}/rotated-secret-update-azure", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_azure);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateAzureError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_cassandra(configuration: &configuration::Configuration, rotated_secret_update_cassandra: models::RotatedSecretUpdateCassandra) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateCassandraError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_cassandra = rotated_secret_update_cassandra;

    let uri_str = format!("{}/rotated-secret-update-cassandra", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_cassandra);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateCassandraError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_custom(configuration: &configuration::Configuration, rotated_secret_update_custom: models::RotatedSecretUpdateCustom) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateCustomError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_custom = rotated_secret_update_custom;

    let uri_str = format!("{}/rotated-secret-update-custom", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_custom);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateCustomError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_dockerhub(configuration: &configuration::Configuration, rotated_secret_update_dockerhub: models::RotatedSecretUpdateDockerhub) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateDockerhubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_dockerhub = rotated_secret_update_dockerhub;

    let uri_str = format!("{}/rotated-secret-update-dockerhub", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_dockerhub);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateDockerhubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_gcp(configuration: &configuration::Configuration, rotated_secret_update_gcp: models::RotatedSecretUpdateGcp) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_gcp = rotated_secret_update_gcp;

    let uri_str = format!("{}/rotated-secret-update-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_gcp);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_hanadb(configuration: &configuration::Configuration, rotated_secret_update_hanadb: models::RotatedSecretUpdateHanadb) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateHanadbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_hanadb = rotated_secret_update_hanadb;

    let uri_str = format!("{}/rotated-secret-update-hanadb", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_hanadb);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateHanadbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_ldap(configuration: &configuration::Configuration, rotated_secret_update_ldap: models::RotatedSecretUpdateLdap) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_ldap = rotated_secret_update_ldap;

    let uri_str = format!("{}/rotated-secret-update-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_ldap);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_mongodb(configuration: &configuration::Configuration, rotated_secret_update_mongodb: models::RotatedSecretUpdateMongodb) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateMongodbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_mongodb = rotated_secret_update_mongodb;

    let uri_str = format!("{}/rotated-secret-update-mongodb", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_mongodb);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateMongodbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_mssql(configuration: &configuration::Configuration, rotated_secret_update_mssql: models::RotatedSecretUpdateMssql) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateMssqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_mssql = rotated_secret_update_mssql;

    let uri_str = format!("{}/rotated-secret-update-mssql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_mssql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateMssqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_mysql(configuration: &configuration::Configuration, rotated_secret_update_mysql: models::RotatedSecretUpdateMysql) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateMysqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_mysql = rotated_secret_update_mysql;

    let uri_str = format!("{}/rotated-secret-update-mysql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_mysql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateMysqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_open_ai(configuration: &configuration::Configuration, rotated_secret_update_open_ai: models::RotatedSecretUpdateOpenAi) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateOpenAiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_open_ai = rotated_secret_update_open_ai;

    let uri_str = format!("{}/rotated-secret-update-openai", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_open_ai);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateOpenAiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_oracledb(configuration: &configuration::Configuration, rotated_secret_update_oracledb: models::RotatedSecretUpdateOracledb) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateOracledbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_oracledb = rotated_secret_update_oracledb;

    let uri_str = format!("{}/rotated-secret-update-oracledb", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_oracledb);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateOracledbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_postgresql(configuration: &configuration::Configuration, rotated_secret_update_postgresql: models::RotatedSecretUpdatePostgresql) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdatePostgresqlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_postgresql = rotated_secret_update_postgresql;

    let uri_str = format!("{}/rotated-secret-update-postgresql", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_postgresql);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdatePostgresqlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_redis(configuration: &configuration::Configuration, rotated_secret_update_redis: models::RotatedSecretUpdateRedis) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateRedisError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_redis = rotated_secret_update_redis;

    let uri_str = format!("{}/rotated-secret-update-redis", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_redis);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateRedisError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_redshift(configuration: &configuration::Configuration, rotated_secret_update_redshift: models::RotatedSecretUpdateRedshift) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateRedshiftError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_redshift = rotated_secret_update_redshift;

    let uri_str = format!("{}/rotated-secret-update-redshift", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_redshift);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateRedshiftError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_snowflake(configuration: &configuration::Configuration, rotated_secret_update_snowflake: models::RotatedSecretUpdateSnowflake) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateSnowflakeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_snowflake = rotated_secret_update_snowflake;

    let uri_str = format!("{}/rotated-secret-update-snowflake", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_snowflake);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateSnowflakeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_splunk(configuration: &configuration::Configuration, rotated_secret_update_splunk: models::RotatedSecretUpdateSplunk) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateSplunkError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_splunk = rotated_secret_update_splunk;

    let uri_str = format!("{}/rotated-secret-update-splunk", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_splunk);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateSplunkError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_ssh(configuration: &configuration::Configuration, rotated_secret_update_ssh: models::RotatedSecretUpdateSsh) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateSshError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_ssh = rotated_secret_update_ssh;

    let uri_str = format!("{}/rotated-secret-update-ssh", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_ssh);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateSshError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn rotated_secret_update_windows(configuration: &configuration::Configuration, rotated_secret_update_windows: models::RotatedSecretUpdateWindows) -> Result<models::RotatedSecretUpdateOutput, Error<RotatedSecretUpdateWindowsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_rotated_secret_update_windows = rotated_secret_update_windows;

    let uri_str = format!("{}/rotated-secret-update-windows", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_rotated_secret_update_windows);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotatedSecretUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<RotatedSecretUpdateWindowsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn set_item_state(configuration: &configuration::Configuration, set_item_state: models::SetItemState) -> Result<serde_json::Value, Error<SetItemStateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_set_item_state = set_item_state;

    let uri_str = format!("{}/set-item-state", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_set_item_state);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<SetItemStateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn set_role_rule(configuration: &configuration::Configuration, set_role_rule: models::SetRoleRule) -> Result<serde_json::Value, Error<SetRoleRuleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_set_role_rule = set_role_rule;

    let uri_str = format!("{}/set-role-rule", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_set_role_rule);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<SetRoleRuleError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn share_item(configuration: &configuration::Configuration, share_item: models::ShareItem) -> Result<models::ShareItemOutput, Error<ShareItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_share_item = share_item;

    let uri_str = format!("{}/share-item", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_share_item);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ShareItemOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ShareItemOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ShareItemError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn sign_data_with_classic_key(configuration: &configuration::Configuration, sign_data_with_classic_key: models::SignDataWithClassicKey) -> Result<models::SignOutput, Error<SignDataWithClassicKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_sign_data_with_classic_key = sign_data_with_classic_key;

    let uri_str = format!("{}/sign-data-with-classic-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_sign_data_with_classic_key);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SignOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SignOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<SignDataWithClassicKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn sign_ec_dsa(configuration: &configuration::Configuration, sign_ec_dsa: models::SignEcDsa) -> Result<models::SignEcDsaOutput, Error<SignEcDsaError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_sign_ec_dsa = sign_ec_dsa;

    let uri_str = format!("{}/sign-ecdsa", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_sign_ec_dsa);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SignEcDsaOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SignEcDsaOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<SignEcDsaError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn sign_gpg(configuration: &configuration::Configuration, sign_gpg: models::SignGpg) -> Result<models::SignGpgOutput, Error<SignGpgError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_sign_gpg = sign_gpg;

    let uri_str = format!("{}/sign-gpg", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_sign_gpg);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SignGpgOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SignGpgOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<SignGpgError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn sign_jwt_with_classic_key(configuration: &configuration::Configuration, sign_jwt_with_classic_key: models::SignJwtWithClassicKey) -> Result<models::SignJwtOutput, Error<SignJwtWithClassicKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_sign_jwt_with_classic_key = sign_jwt_with_classic_key;

    let uri_str = format!("{}/sign-jwt-with-classic-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_sign_jwt_with_classic_key);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SignJwtOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SignJwtOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<SignJwtWithClassicKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn sign_pkcs1(configuration: &configuration::Configuration, sign_pkcs1: models::SignPkcs1) -> Result<models::SignPkcs1Output, Error<SignPkcs1Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_sign_pkcs1 = sign_pkcs1;

    let uri_str = format!("{}/sign-pkcs1", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_sign_pkcs1);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SignPkcs1Output`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SignPkcs1Output`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<SignPkcs1Error> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn sign_pki_cert_with_classic_key(configuration: &configuration::Configuration, sign_pki_cert_with_classic_key: models::SignPkiCertWithClassicKey) -> Result<models::SignPkiCertOutput, Error<SignPkiCertWithClassicKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_sign_pki_cert_with_classic_key = sign_pki_cert_with_classic_key;

    let uri_str = format!("{}/sign-pki-cert-with-classic-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_sign_pki_cert_with_classic_key);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SignPkiCertOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SignPkiCertOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<SignPkiCertWithClassicKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn sign_rsa_ssa_pss(configuration: &configuration::Configuration, sign_rsa_ssa_pss: models::SignRsaSsaPss) -> Result<models::SignRsaSsaPssOutput, Error<SignRsaSsaPssError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_sign_rsa_ssa_pss = sign_rsa_ssa_pss;

    let uri_str = format!("{}/sign-rsassa-pss", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_sign_rsa_ssa_pss);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SignRsaSsaPssOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SignRsaSsaPssOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<SignRsaSsaPssError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn static_creds_auth(configuration: &configuration::Configuration, static_creds_auth: models::StaticCredsAuth) -> Result<models::StaticCredsAuthOutput, Error<StaticCredsAuthError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_static_creds_auth = static_creds_auth;

    let uri_str = format!("{}/static-creds-auth", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_static_creds_auth);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::StaticCredsAuthOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::StaticCredsAuthOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<StaticCredsAuthError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn static_secret_delete_sync(configuration: &configuration::Configuration, static_secret_delete_sync: models::StaticSecretDeleteSync) -> Result<models::StaticSecretDeleteSyncOutput, Error<StaticSecretDeleteSyncError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_static_secret_delete_sync = static_secret_delete_sync;

    let uri_str = format!("{}/static-secret-delete-sync", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_static_secret_delete_sync);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::StaticSecretDeleteSyncOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::StaticSecretDeleteSyncOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<StaticSecretDeleteSyncError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn static_secret_sync(configuration: &configuration::Configuration, static_secret_sync: models::StaticSecretSync) -> Result<models::SecretSyncOutput, Error<StaticSecretSyncError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_static_secret_sync = static_secret_sync;

    let uri_str = format!("{}/static-secret-sync", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_static_secret_sync);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::SecretSyncOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::SecretSyncOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<StaticSecretSyncError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_artifactory(configuration: &configuration::Configuration, target_create_artifactory: models::TargetCreateArtifactory) -> Result<models::TargetCreateOutput, Error<TargetCreateArtifactoryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_artifactory = target_create_artifactory;

    let uri_str = format!("{}/target-create-artifactory", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_artifactory);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateArtifactoryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_aws(configuration: &configuration::Configuration, target_create_aws: models::TargetCreateAws) -> Result<models::TargetCreateOutput, Error<TargetCreateAwsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_aws = target_create_aws;

    let uri_str = format!("{}/target-create-aws", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_aws);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateAwsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_azure(configuration: &configuration::Configuration, target_create_azure: models::TargetCreateAzure) -> Result<models::TargetCreateOutput, Error<TargetCreateAzureError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_azure = target_create_azure;

    let uri_str = format!("{}/target-create-azure", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_azure);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateAzureError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_db(configuration: &configuration::Configuration, target_create_db: models::TargetCreateDb) -> Result<models::TargetCreateOutput, Error<TargetCreateDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_db = target_create_db;

    let uri_str = format!("{}/target-create-db", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_db);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_dockerhub(configuration: &configuration::Configuration, target_create_dockerhub: models::TargetCreateDockerhub) -> Result<models::TargetCreateOutput, Error<TargetCreateDockerhubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_dockerhub = target_create_dockerhub;

    let uri_str = format!("{}/target-create-dockerhub", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_dockerhub);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateDockerhubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_eks(configuration: &configuration::Configuration, target_create_eks: models::TargetCreateEks) -> Result<models::TargetCreateOutput, Error<TargetCreateEksError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_eks = target_create_eks;

    let uri_str = format!("{}/target-create-eks", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_eks);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateEksError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_gcp(configuration: &configuration::Configuration, target_create_gcp: models::TargetCreateGcp) -> Result<models::TargetCreateOutput, Error<TargetCreateGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_gcp = target_create_gcp;

    let uri_str = format!("{}/target-create-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_gcp);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_gemini(configuration: &configuration::Configuration, target_create_gemini: models::TargetCreateGemini) -> Result<models::TargetCreateOutput, Error<TargetCreateGeminiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_gemini = target_create_gemini;

    let uri_str = format!("{}/target-create-gemini", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_gemini);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateGeminiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_github(configuration: &configuration::Configuration, target_create_github: models::TargetCreateGithub) -> Result<models::TargetCreateOutput, Error<TargetCreateGithubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_github = target_create_github;

    let uri_str = format!("{}/target-create-github", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_github);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateGithubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_gitlab(configuration: &configuration::Configuration, target_create_gitlab: models::TargetCreateGitlab) -> Result<models::TargetCreateOutput, Error<TargetCreateGitlabError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_gitlab = target_create_gitlab;

    let uri_str = format!("{}/target-create-gitlab", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_gitlab);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateGitlabError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_gke(configuration: &configuration::Configuration, target_create_gke: models::TargetCreateGke) -> Result<models::TargetCreateOutput, Error<TargetCreateGkeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_gke = target_create_gke;

    let uri_str = format!("{}/target-create-gke", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_gke);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateGkeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_global_sign(configuration: &configuration::Configuration, target_create_global_sign: models::TargetCreateGlobalSign) -> Result<models::TargetCreateOutput, Error<TargetCreateGlobalSignError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_global_sign = target_create_global_sign;

    let uri_str = format!("{}/target-create-globalsign", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_global_sign);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateGlobalSignError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_global_sign_atlas(configuration: &configuration::Configuration, target_create_global_sign_atlas: models::TargetCreateGlobalSignAtlas) -> Result<models::TargetCreateOutput, Error<TargetCreateGlobalSignAtlasError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_global_sign_atlas = target_create_global_sign_atlas;

    let uri_str = format!("{}/target-create-globalsign-atlas", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_global_sign_atlas);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateGlobalSignAtlasError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_godaddy(configuration: &configuration::Configuration, target_create_godaddy: models::TargetCreateGodaddy) -> Result<models::TargetCreateOutput, Error<TargetCreateGodaddyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_godaddy = target_create_godaddy;

    let uri_str = format!("{}/target-create-godaddy", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_godaddy);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateGodaddyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_hashi_vault(configuration: &configuration::Configuration, target_create_hashi_vault: models::TargetCreateHashiVault) -> Result<models::TargetCreateOutput, Error<TargetCreateHashiVaultError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_hashi_vault = target_create_hashi_vault;

    let uri_str = format!("{}/target-create-hashi-vault", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_hashi_vault);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateHashiVaultError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_k8s(configuration: &configuration::Configuration, target_create_k8s: models::TargetCreateK8s) -> Result<models::TargetCreateOutput, Error<TargetCreateK8sError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_k8s = target_create_k8s;

    let uri_str = format!("{}/target-create-k8s", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_k8s);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateK8sError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_ldap(configuration: &configuration::Configuration, target_create_ldap: models::TargetCreateLdap) -> Result<models::TargetCreateOutput, Error<TargetCreateLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_ldap = target_create_ldap;

    let uri_str = format!("{}/target-create-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_ldap);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_lets_encrypt(configuration: &configuration::Configuration, target_create_lets_encrypt: models::TargetCreateLetsEncrypt) -> Result<models::TargetCreateOutput, Error<TargetCreateLetsEncryptError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_lets_encrypt = target_create_lets_encrypt;

    let uri_str = format!("{}/target-create-lets-encrypt", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_lets_encrypt);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateLetsEncryptError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_linked(configuration: &configuration::Configuration, target_create_linked: models::TargetCreateLinked) -> Result<models::TargetCreateOutput, Error<TargetCreateLinkedError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_linked = target_create_linked;

    let uri_str = format!("{}/target-create-linked", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_linked);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateLinkedError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_open_ai(configuration: &configuration::Configuration, target_create_open_ai: models::TargetCreateOpenAi) -> Result<models::TargetCreateOutput, Error<TargetCreateOpenAiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_open_ai = target_create_open_ai;

    let uri_str = format!("{}/target-create-openai", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_open_ai);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateOpenAiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_ping(configuration: &configuration::Configuration, target_create_ping: models::TargetCreatePing) -> Result<models::TargetCreateOutput, Error<TargetCreatePingError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_ping = target_create_ping;

    let uri_str = format!("{}/target-create-ping", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_ping);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreatePingError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_rabbit_mq(configuration: &configuration::Configuration, target_create_rabbit_mq: models::TargetCreateRabbitMq) -> Result<models::TargetCreateOutput, Error<TargetCreateRabbitMqError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_rabbit_mq = target_create_rabbit_mq;

    let uri_str = format!("{}/target-create-rabbitmq", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_rabbit_mq);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateRabbitMqError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_salesforce(configuration: &configuration::Configuration, target_create_salesforce: models::TargetCreateSalesforce) -> Result<models::TargetCreateOutput, Error<TargetCreateSalesforceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_salesforce = target_create_salesforce;

    let uri_str = format!("{}/target-create-salesforce", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_salesforce);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateSalesforceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_sectigo(configuration: &configuration::Configuration, target_create_sectigo: models::TargetCreateSectigo) -> Result<models::TargetCreateOutput, Error<TargetCreateSectigoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_sectigo = target_create_sectigo;

    let uri_str = format!("{}/target-create-sectigo", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_sectigo);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateSectigoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_splunk(configuration: &configuration::Configuration, target_create_splunk: models::TargetCreateSplunk) -> Result<models::TargetCreateOutput, Error<TargetCreateSplunkError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_splunk = target_create_splunk;

    let uri_str = format!("{}/target-create-splunk", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_splunk);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateSplunkError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_ssh(configuration: &configuration::Configuration, target_create_ssh: models::TargetCreateSsh) -> Result<models::TargetCreateOutput, Error<TargetCreateSshError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_ssh = target_create_ssh;

    let uri_str = format!("{}/target-create-ssh", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_ssh);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateSshError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_web(configuration: &configuration::Configuration, target_create_web: models::TargetCreateWeb) -> Result<models::TargetCreateOutput, Error<TargetCreateWebError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_web = target_create_web;

    let uri_str = format!("{}/target-create-web", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_web);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateWebError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_windows(configuration: &configuration::Configuration, target_create_windows: models::TargetCreateWindows) -> Result<models::TargetCreateOutput, Error<TargetCreateWindowsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_windows = target_create_windows;

    let uri_str = format!("{}/target-create-windows", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_windows);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateWindowsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_create_zero_ssl(configuration: &configuration::Configuration, target_create_zero_ssl: models::TargetCreateZeroSsl) -> Result<models::TargetCreateOutput, Error<TargetCreateZeroSslError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_create_zero_ssl = target_create_zero_ssl;

    let uri_str = format!("{}/target-create-zerossl", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_create_zero_ssl);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetCreateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetCreateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetCreateZeroSslError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_delete(configuration: &configuration::Configuration, target_delete: models::TargetDelete) -> Result<serde_json::Value, Error<TargetDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_delete = target_delete;

    let uri_str = format!("{}/target-delete", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_delete);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_get(configuration: &configuration::Configuration, target_get: models::TargetGet) -> Result<models::Target, Error<TargetGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_get = target_get;

    let uri_str = format!("{}/target-get", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_get);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::Target`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::Target`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_get_details(configuration: &configuration::Configuration, target_get_details: models::TargetGetDetails) -> Result<models::GetTargetDetailsOutput, Error<TargetGetDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_get_details = target_get_details;

    let uri_str = format!("{}/target-get-details", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_get_details);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::GetTargetDetailsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::GetTargetDetailsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetGetDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_list(configuration: &configuration::Configuration, target_list: models::TargetList) -> Result<models::ListTargetsOutput, Error<TargetListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_list = target_list;

    let uri_str = format!("{}/target-list", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_list);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ListTargetsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ListTargetsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_artifactory(configuration: &configuration::Configuration, target_update_artifactory: models::TargetUpdateArtifactory) -> Result<models::TargetUpdateOutput, Error<TargetUpdateArtifactoryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_artifactory = target_update_artifactory;

    let uri_str = format!("{}/target-update-artifactory", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_artifactory);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateArtifactoryError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_aws(configuration: &configuration::Configuration, target_update_aws: models::TargetUpdateAws) -> Result<models::TargetUpdateOutput, Error<TargetUpdateAwsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_aws = target_update_aws;

    let uri_str = format!("{}/target-update-aws", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_aws);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateAwsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_azure(configuration: &configuration::Configuration, target_update_azure: models::TargetUpdateAzure) -> Result<models::TargetUpdateOutput, Error<TargetUpdateAzureError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_azure = target_update_azure;

    let uri_str = format!("{}/target-update-azure", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_azure);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateAzureError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_db(configuration: &configuration::Configuration, target_update_db: models::TargetUpdateDb) -> Result<models::TargetUpdateOutput, Error<TargetUpdateDbError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_db = target_update_db;

    let uri_str = format!("{}/target-update-db", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_db);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateDbError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_dockerhub(configuration: &configuration::Configuration, target_update_dockerhub: models::TargetUpdateDockerhub) -> Result<models::TargetUpdateOutput, Error<TargetUpdateDockerhubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_dockerhub = target_update_dockerhub;

    let uri_str = format!("{}/target-update-dockerhub", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_dockerhub);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateDockerhubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_eks(configuration: &configuration::Configuration, target_update_eks: models::TargetUpdateEks) -> Result<models::TargetUpdateOutput, Error<TargetUpdateEksError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_eks = target_update_eks;

    let uri_str = format!("{}/target-update-eks", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_eks);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateEksError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_gcp(configuration: &configuration::Configuration, target_update_gcp: models::TargetUpdateGcp) -> Result<models::TargetUpdateOutput, Error<TargetUpdateGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_gcp = target_update_gcp;

    let uri_str = format!("{}/target-update-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_gcp);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_gemini(configuration: &configuration::Configuration, target_update_gemini: models::TargetUpdateGemini) -> Result<models::TargetUpdateOutput, Error<TargetUpdateGeminiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_gemini = target_update_gemini;

    let uri_str = format!("{}/target-update-gemini", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_gemini);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateGeminiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_github(configuration: &configuration::Configuration, target_update_github: models::TargetUpdateGithub) -> Result<models::TargetUpdateOutput, Error<TargetUpdateGithubError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_github = target_update_github;

    let uri_str = format!("{}/target-update-github", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_github);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateGithubError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_gitlab(configuration: &configuration::Configuration, target_update_gitlab: models::TargetUpdateGitlab) -> Result<models::TargetUpdateOutput, Error<TargetUpdateGitlabError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_gitlab = target_update_gitlab;

    let uri_str = format!("{}/target-update-gitlab", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_gitlab);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateGitlabError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_gke(configuration: &configuration::Configuration, target_update_gke: models::TargetUpdateGke) -> Result<models::TargetUpdateOutput, Error<TargetUpdateGkeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_gke = target_update_gke;

    let uri_str = format!("{}/target-update-gke", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_gke);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateGkeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_global_sign(configuration: &configuration::Configuration, target_update_global_sign: models::TargetUpdateGlobalSign) -> Result<models::TargetUpdateOutput, Error<TargetUpdateGlobalSignError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_global_sign = target_update_global_sign;

    let uri_str = format!("{}/target-update-globalsign", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_global_sign);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateGlobalSignError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_global_sign_atlas(configuration: &configuration::Configuration, target_update_global_sign_atlas: models::TargetUpdateGlobalSignAtlas) -> Result<models::TargetUpdateOutput, Error<TargetUpdateGlobalSignAtlasError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_global_sign_atlas = target_update_global_sign_atlas;

    let uri_str = format!("{}/target-update-globalsign-atlas", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_global_sign_atlas);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateGlobalSignAtlasError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_godaddy(configuration: &configuration::Configuration, target_update_godaddy: models::TargetUpdateGodaddy) -> Result<models::TargetUpdateOutput, Error<TargetUpdateGodaddyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_godaddy = target_update_godaddy;

    let uri_str = format!("{}/target-update-godaddy", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_godaddy);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateGodaddyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_hashi_vault(configuration: &configuration::Configuration, target_update_hashi_vault: models::TargetUpdateHashiVault) -> Result<models::TargetUpdateOutput, Error<TargetUpdateHashiVaultError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_hashi_vault = target_update_hashi_vault;

    let uri_str = format!("{}/target-update-hashi-vault", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_hashi_vault);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateHashiVaultError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_k8s(configuration: &configuration::Configuration, target_update_k8s: models::TargetUpdateK8s) -> Result<models::TargetUpdateOutput, Error<TargetUpdateK8sError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_k8s = target_update_k8s;

    let uri_str = format!("{}/target-update-k8s", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_k8s);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateK8sError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_ldap(configuration: &configuration::Configuration, target_update_ldap: models::TargetUpdateLdap) -> Result<models::TargetUpdateOutput, Error<TargetUpdateLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_ldap = target_update_ldap;

    let uri_str = format!("{}/target-update-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_ldap);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_lets_encrypt(configuration: &configuration::Configuration, target_update_lets_encrypt: models::TargetUpdateLetsEncrypt) -> Result<models::TargetUpdateOutput, Error<TargetUpdateLetsEncryptError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_lets_encrypt = target_update_lets_encrypt;

    let uri_str = format!("{}/target-update-lets-encrypt", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_lets_encrypt);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateLetsEncryptError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_linked(configuration: &configuration::Configuration, target_update_linked: models::TargetUpdateLinked) -> Result<models::TargetUpdateOutput, Error<TargetUpdateLinkedError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_linked = target_update_linked;

    let uri_str = format!("{}/target-update-linked", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_linked);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateLinkedError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_open_ai(configuration: &configuration::Configuration, target_update_open_ai: models::TargetUpdateOpenAi) -> Result<models::TargetUpdateOutput, Error<TargetUpdateOpenAiError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_open_ai = target_update_open_ai;

    let uri_str = format!("{}/target-update-openai", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_open_ai);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateOpenAiError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_ping(configuration: &configuration::Configuration, target_update_ping: models::TargetUpdatePing) -> Result<models::TargetUpdateOutput, Error<TargetUpdatePingError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_ping = target_update_ping;

    let uri_str = format!("{}/target-update-ping", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_ping);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdatePingError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_rabbit_mq(configuration: &configuration::Configuration, target_update_rabbit_mq: models::TargetUpdateRabbitMq) -> Result<models::TargetUpdateOutput, Error<TargetUpdateRabbitMqError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_rabbit_mq = target_update_rabbit_mq;

    let uri_str = format!("{}/target-update-rabbitmq", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_rabbit_mq);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateRabbitMqError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_salesforce(configuration: &configuration::Configuration, target_update_salesforce: models::TargetUpdateSalesforce) -> Result<models::TargetUpdateOutput, Error<TargetUpdateSalesforceError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_salesforce = target_update_salesforce;

    let uri_str = format!("{}/target-update-salesforce", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_salesforce);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateSalesforceError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_sectigo(configuration: &configuration::Configuration, target_update_sectigo: models::TargetUpdateSectigo) -> Result<models::TargetUpdateOutput, Error<TargetUpdateSectigoError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_sectigo = target_update_sectigo;

    let uri_str = format!("{}/target-update-sectigo", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_sectigo);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateSectigoError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_ssh(configuration: &configuration::Configuration, target_update_ssh: models::TargetUpdateSsh) -> Result<models::TargetUpdateOutput, Error<TargetUpdateSshError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_ssh = target_update_ssh;

    let uri_str = format!("{}/target-update-ssh", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_ssh);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateSshError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_web(configuration: &configuration::Configuration, target_update_web: models::TargetUpdateWeb) -> Result<models::TargetUpdateOutput, Error<TargetUpdateWebError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_web = target_update_web;

    let uri_str = format!("{}/target-update-web", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_web);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateWebError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_windows(configuration: &configuration::Configuration, target_update_windows: models::TargetUpdateWindows) -> Result<models::TargetUpdateOutput, Error<TargetUpdateWindowsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_windows = target_update_windows;

    let uri_str = format!("{}/target-update-windows", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_windows);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateWindowsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn target_update_zero_ssl(configuration: &configuration::Configuration, target_update_zero_ssl: models::TargetUpdateZeroSsl) -> Result<models::TargetUpdateOutput, Error<TargetUpdateZeroSslError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_target_update_zero_ssl = target_update_zero_ssl;

    let uri_str = format!("{}/target-update-zerossl", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_target_update_zero_ssl);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TargetUpdateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TargetUpdateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TargetUpdateZeroSslError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn tokenize(configuration: &configuration::Configuration, tokenize: models::Tokenize) -> Result<models::TokenizeOutput, Error<TokenizeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_tokenize = tokenize;

    let uri_str = format!("{}/tokenize", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_tokenize);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TokenizeOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TokenizeOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TokenizeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn tokenize_batch(configuration: &configuration::Configuration, batch_tokenization_request_line: Vec<models::BatchTokenizationRequestLine>) -> Result<models::TokenizeOutput, Error<TokenizeBatchError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_batch_tokenization_request_line = batch_tokenization_request_line;

    let uri_str = format!("{}/tokenize-batch", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_batch_tokenization_request_line);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::TokenizeOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::TokenizeOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<TokenizeBatchError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn uid_create_child_token(configuration: &configuration::Configuration, uid_create_child_token: models::UidCreateChildToken) -> Result<models::UidCreateChildTokenOutput, Error<UidCreateChildTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_uid_create_child_token = uid_create_child_token;

    let uri_str = format!("{}/uid-create-child-token", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_uid_create_child_token);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UidCreateChildTokenOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UidCreateChildTokenOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UidCreateChildTokenError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn uid_generate_token(configuration: &configuration::Configuration, uid_generate_token: models::UidGenerateToken) -> Result<models::UidGenerateTokenOutput, Error<UidGenerateTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_uid_generate_token = uid_generate_token;

    let uri_str = format!("{}/uid-generate-token", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_uid_generate_token);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UidGenerateTokenOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UidGenerateTokenOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UidGenerateTokenError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn uid_list_children(configuration: &configuration::Configuration, uid_list_children: models::UidListChildren) -> Result<models::UniversalIdentityDetails, Error<UidListChildrenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_uid_list_children = uid_list_children;

    let uri_str = format!("{}/uid-list-children", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_uid_list_children);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UniversalIdentityDetails`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UniversalIdentityDetails`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UidListChildrenError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn uid_revoke_token(configuration: &configuration::Configuration, uid_revoke_token: models::UidRevokeToken) -> Result<serde_json::Value, Error<UidRevokeTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_uid_revoke_token = uid_revoke_token;

    let uri_str = format!("{}/uid-revoke-token", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_uid_revoke_token);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UidRevokeTokenError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn uid_rotate_token(configuration: &configuration::Configuration, uid_rotate_token: models::UidRotateToken) -> Result<models::UidRotateTokenOutput, Error<UidRotateTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_uid_rotate_token = uid_rotate_token;

    let uri_str = format!("{}/uid-rotate-token", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_uid_rotate_token);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UidRotateTokenOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UidRotateTokenOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UidRotateTokenError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn unwrap_token(configuration: &configuration::Configuration, unwrap_token: models::UnwrapToken) -> Result<models::UnwrapTokenOutput, Error<UnwrapTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_unwrap_token = unwrap_token;

    let uri_str = format!("{}/unwrap-token", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_unwrap_token);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UnwrapTokenOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UnwrapTokenOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UnwrapTokenError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_account_settings(configuration: &configuration::Configuration, update_account_settings: models::UpdateAccountSettings) -> Result<models::UpdateAccountSettingsOutput, Error<UpdateAccountSettingsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_account_settings = update_account_settings;

    let uri_str = format!("{}/update-account-settings", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_account_settings);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateAccountSettingsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateAccountSettingsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAccountSettingsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_artifactory_target(configuration: &configuration::Configuration, update_artifactory_target: models::UpdateArtifactoryTarget) -> Result<models::UpdateArtifactoryTargetOutput, Error<UpdateArtifactoryTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_artifactory_target = update_artifactory_target;

    let uri_str = format!("{}/update-artifactory-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_artifactory_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateArtifactoryTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateArtifactoryTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateArtifactoryTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_assoc(configuration: &configuration::Configuration, update_assoc: models::UpdateAssoc) -> Result<serde_json::Value, Error<UpdateAssocError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_assoc = update_assoc;

    let uri_str = format!("{}/update-assoc", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_assoc);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAssocError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method(configuration: &configuration::Configuration, update_auth_method: models::UpdateAuthMethod) -> Result<models::UpdateAuthMethodOutput, Error<UpdateAuthMethodError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method = update_auth_method;

    let uri_str = format!("{}/update-auth-method", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateAuthMethodOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateAuthMethodOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method_awsiam(configuration: &configuration::Configuration, update_auth_method_awsiam: models::UpdateAuthMethodAwsiam) -> Result<serde_json::Value, Error<UpdateAuthMethodAwsiamError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method_awsiam = update_auth_method_awsiam;

    let uri_str = format!("{}/update-auth-method-aws-iam", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method_awsiam);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodAwsiamError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method_azure_ad(configuration: &configuration::Configuration, update_auth_method_azure_ad: models::UpdateAuthMethodAzureAd) -> Result<serde_json::Value, Error<UpdateAuthMethodAzureAdError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method_azure_ad = update_auth_method_azure_ad;

    let uri_str = format!("{}/update-auth-method-azure-ad", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method_azure_ad);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodAzureAdError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method_cert(configuration: &configuration::Configuration, update_auth_method_cert: models::UpdateAuthMethodCert) -> Result<models::UpdateAuthMethodCertOutput, Error<UpdateAuthMethodCertError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method_cert = update_auth_method_cert;

    let uri_str = format!("{}/update-auth-method-cert", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method_cert);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateAuthMethodCertOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateAuthMethodCertOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodCertError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method_gcp(configuration: &configuration::Configuration, update_auth_method_gcp: models::UpdateAuthMethodGcp) -> Result<serde_json::Value, Error<UpdateAuthMethodGcpError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method_gcp = update_auth_method_gcp;

    let uri_str = format!("{}/update-auth-method-gcp", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method_gcp);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodGcpError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method_k8_s(configuration: &configuration::Configuration, update_auth_method_k8_s: models::UpdateAuthMethodK8S) -> Result<models::UpdateAuthMethodK8SOutput, Error<UpdateAuthMethodK8SError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method_k8_s = update_auth_method_k8_s;

    let uri_str = format!("{}/update-auth-method-k8s", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method_k8_s);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateAuthMethodK8SOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateAuthMethodK8SOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodK8SError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method_ldap(configuration: &configuration::Configuration, update_auth_method_ldap: models::UpdateAuthMethodLdap) -> Result<models::UpdateAuthMethodLdapOutput, Error<UpdateAuthMethodLdapError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method_ldap = update_auth_method_ldap;

    let uri_str = format!("{}/update-auth-method-ldap", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method_ldap);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateAuthMethodLdapOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateAuthMethodLdapOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodLdapError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method_o_auth2(configuration: &configuration::Configuration, update_auth_method_o_auth2: models::UpdateAuthMethodOAuth2) -> Result<serde_json::Value, Error<UpdateAuthMethodOAuth2Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method_o_auth2 = update_auth_method_o_auth2;

    let uri_str = format!("{}/update-auth-method-oauth2", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method_o_auth2);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodOAuth2Error> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method_oci(configuration: &configuration::Configuration, update_auth_method_oci: models::UpdateAuthMethodOci) -> Result<models::UpdateAuthMethodOciOutput, Error<UpdateAuthMethodOciError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method_oci = update_auth_method_oci;

    let uri_str = format!("{}/update-auth-method-oci", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method_oci);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateAuthMethodOciOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateAuthMethodOciOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodOciError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method_oidc(configuration: &configuration::Configuration, update_auth_method_oidc: models::UpdateAuthMethodOidc) -> Result<serde_json::Value, Error<UpdateAuthMethodOidcError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method_oidc = update_auth_method_oidc;

    let uri_str = format!("{}/update-auth-method-oidc", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method_oidc);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodOidcError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method_saml(configuration: &configuration::Configuration, update_auth_method_saml: models::UpdateAuthMethodSaml) -> Result<serde_json::Value, Error<UpdateAuthMethodSamlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method_saml = update_auth_method_saml;

    let uri_str = format!("{}/update-auth-method-saml", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method_saml);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodSamlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_auth_method_universal_identity(configuration: &configuration::Configuration, update_auth_method_universal_identity: models::UpdateAuthMethodUniversalIdentity) -> Result<serde_json::Value, Error<UpdateAuthMethodUniversalIdentityError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_auth_method_universal_identity = update_auth_method_universal_identity;

    let uri_str = format!("{}/update-auth-method-universal-identity", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_auth_method_universal_identity);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAuthMethodUniversalIdentityError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_aws_target(configuration: &configuration::Configuration, update_aws_target: models::UpdateAwsTarget) -> Result<serde_json::Value, Error<UpdateAwsTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_aws_target = update_aws_target;

    let uri_str = format!("{}/update-aws-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_aws_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAwsTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_aws_target_details(configuration: &configuration::Configuration, update_aws_target_details: models::UpdateAwsTargetDetails) -> Result<models::UpdateTargetOutput, Error<UpdateAwsTargetDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_aws_target_details = update_aws_target_details;

    let uri_str = format!("{}/update-aws-target-details", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_aws_target_details);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAwsTargetDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_azure_target(configuration: &configuration::Configuration, update_azure_target: models::UpdateAzureTarget) -> Result<models::UpdateAzureTargetOutput, Error<UpdateAzureTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_azure_target = update_azure_target;

    let uri_str = format!("{}/update-azure-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_azure_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateAzureTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateAzureTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateAzureTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_certificate_value(configuration: &configuration::Configuration, update_certificate_value: models::UpdateCertificateValue) -> Result<models::UpdateCertificateOutput, Error<UpdateCertificateValueError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_certificate_value = update_certificate_value;

    let uri_str = format!("{}/update-certificate-value", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_certificate_value);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateCertificateOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateCertificateOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateCertificateValueError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_classic_key_certificate(configuration: &configuration::Configuration, update_classic_key_certificate: models::UpdateClassicKeyCertificate) -> Result<serde_json::Value, Error<UpdateClassicKeyCertificateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_classic_key_certificate = update_classic_key_certificate;

    let uri_str = format!("{}/update-classic-key-certificate", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_classic_key_certificate);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateClassicKeyCertificateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_db_target(configuration: &configuration::Configuration, update_db_target: models::UpdateDbTarget) -> Result<models::UpdateDbTargetOutput, Error<UpdateDbTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_db_target = update_db_target;

    let uri_str = format!("{}/update-db-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_db_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateDbTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateDbTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateDbTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_db_target_details(configuration: &configuration::Configuration, update_db_target_details: models::UpdateDbTargetDetails) -> Result<models::UpdateTargetOutput, Error<UpdateDbTargetDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_db_target_details = update_db_target_details;

    let uri_str = format!("{}/update-db-target-details", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_db_target_details);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateDbTargetDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_dockerhub_target(configuration: &configuration::Configuration, update_dockerhub_target: models::UpdateDockerhubTarget) -> Result<models::UpdateDockerhubTargetOutput, Error<UpdateDockerhubTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_dockerhub_target = update_dockerhub_target;

    let uri_str = format!("{}/update-dockerhub-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_dockerhub_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateDockerhubTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateDockerhubTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateDockerhubTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_eks_target(configuration: &configuration::Configuration, update_eks_target: models::UpdateEksTarget) -> Result<models::UpdateEksTargetOutput, Error<UpdateEksTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_eks_target = update_eks_target;

    let uri_str = format!("{}/update-eks-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_eks_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateEksTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateEksTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateEksTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_event_forwarder(configuration: &configuration::Configuration, update_event_forwarder: models::UpdateEventForwarder) -> Result<serde_json::Value, Error<UpdateEventForwarderError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_event_forwarder = update_event_forwarder;

    let uri_str = format!("{}/update-event-forwarder", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_event_forwarder);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateEventForwarderError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_gcp_target(configuration: &configuration::Configuration, update_gcp_target: models::UpdateGcpTarget) -> Result<models::UpdateGcpTargetOutput, Error<UpdateGcpTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_gcp_target = update_gcp_target;

    let uri_str = format!("{}/update-gcp-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_gcp_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateGcpTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateGcpTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateGcpTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_github_target(configuration: &configuration::Configuration, update_github_target: models::UpdateGithubTarget) -> Result<models::UpdateGithubTargetOutput, Error<UpdateGithubTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_github_target = update_github_target;

    let uri_str = format!("{}/update-github-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_github_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateGithubTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateGithubTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateGithubTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_gitlab_target(configuration: &configuration::Configuration, update_gitlab_target: models::UpdateGitlabTarget) -> Result<models::UpdateGitlabTargetOutput, Error<UpdateGitlabTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_gitlab_target = update_gitlab_target;

    let uri_str = format!("{}/update-gitlab-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_gitlab_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateGitlabTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateGitlabTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateGitlabTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_gke_target(configuration: &configuration::Configuration, update_gke_target: models::UpdateGkeTarget) -> Result<models::UpdateGkeTargetOutput, Error<UpdateGkeTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_gke_target = update_gke_target;

    let uri_str = format!("{}/update-gke-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_gke_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateGkeTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateGkeTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateGkeTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_global_sign_atlas_target(configuration: &configuration::Configuration, update_global_sign_atlas_target: models::UpdateGlobalSignAtlasTarget) -> Result<models::UpdateGlobalSignAtlasTargetOutput, Error<UpdateGlobalSignAtlasTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_global_sign_atlas_target = update_global_sign_atlas_target;

    let uri_str = format!("{}/update-globalsign-atlas-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_global_sign_atlas_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateGlobalSignAtlasTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateGlobalSignAtlasTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateGlobalSignAtlasTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_global_sign_target(configuration: &configuration::Configuration, update_global_sign_target: models::UpdateGlobalSignTarget) -> Result<models::UpdateGlobalSignTargetOutput, Error<UpdateGlobalSignTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_global_sign_target = update_global_sign_target;

    let uri_str = format!("{}/update-globalsign-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_global_sign_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateGlobalSignTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateGlobalSignTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateGlobalSignTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_godaddy_target(configuration: &configuration::Configuration, update_godaddy_target: models::UpdateGodaddyTarget) -> Result<models::UpdateGodaddyTargetOutput, Error<UpdateGodaddyTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_godaddy_target = update_godaddy_target;

    let uri_str = format!("{}/update-godaddy-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_godaddy_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateGodaddyTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateGodaddyTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateGodaddyTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_group(configuration: &configuration::Configuration, update_group: models::UpdateGroup) -> Result<models::UpdateGroupOutput, Error<UpdateGroupError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_group = update_group;

    let uri_str = format!("{}/update-group", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_group);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateGroupOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateGroupOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateGroupError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_hashi_vault_target(configuration: &configuration::Configuration, update_hashi_vault_target: models::UpdateHashiVaultTarget) -> Result<models::UpdateHashiVaultTargetOutput, Error<UpdateHashiVaultTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_hashi_vault_target = update_hashi_vault_target;

    let uri_str = format!("{}/update-hashi-vault-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_hashi_vault_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateHashiVaultTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateHashiVaultTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateHashiVaultTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_item(configuration: &configuration::Configuration, update_item: models::UpdateItem) -> Result<models::UpdateItemOutput, Error<UpdateItemError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_item = update_item;

    let uri_str = format!("{}/update-item", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_item);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateItemOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateItemOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateItemError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_ldap_target(configuration: &configuration::Configuration, update_ldap_target: models::UpdateLdapTarget) -> Result<models::UpdateLdapTargetOutput, Error<UpdateLdapTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_ldap_target = update_ldap_target;

    let uri_str = format!("{}/update-ldap-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_ldap_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateLdapTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateLdapTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateLdapTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_ldap_target_details(configuration: &configuration::Configuration, update_ldap_target_details: models::UpdateLdapTargetDetails) -> Result<models::UpdateTargetOutput, Error<UpdateLdapTargetDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_ldap_target_details = update_ldap_target_details;

    let uri_str = format!("{}/update-ldap-target-details", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_ldap_target_details);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateLdapTargetDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_linked_target(configuration: &configuration::Configuration, update_linked_target: models::UpdateLinkedTarget) -> Result<serde_json::Value, Error<UpdateLinkedTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_linked_target = update_linked_target;

    let uri_str = format!("{}/update-linked-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_linked_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateLinkedTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_native_k8_s_target(configuration: &configuration::Configuration, update_native_k8_s_target: models::UpdateNativeK8STarget) -> Result<models::UpdateNativeK8STargetOutput, Error<UpdateNativeK8STargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_native_k8_s_target = update_native_k8_s_target;

    let uri_str = format!("{}/update-k8s-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_native_k8_s_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateNativeK8STargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateNativeK8STargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateNativeK8STargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_oidc_app(configuration: &configuration::Configuration, update_oidc_app: models::UpdateOidcApp) -> Result<serde_json::Value, Error<UpdateOidcAppError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_oidc_app = update_oidc_app;

    let uri_str = format!("{}/update-oidc-app", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_oidc_app);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateOidcAppError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_ping_target(configuration: &configuration::Configuration, update_ping_target: models::UpdatePingTarget) -> Result<serde_json::Value, Error<UpdatePingTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_ping_target = update_ping_target;

    let uri_str = format!("{}/update-ping-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_ping_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdatePingTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_pki_cert_issuer(configuration: &configuration::Configuration, update_pki_cert_issuer: models::UpdatePkiCertIssuer) -> Result<models::UpdatePkiCertIssuerOutput, Error<UpdatePkiCertIssuerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_pki_cert_issuer = update_pki_cert_issuer;

    let uri_str = format!("{}/update-pki-cert-issuer", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_pki_cert_issuer);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdatePkiCertIssuerOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdatePkiCertIssuerOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdatePkiCertIssuerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_rabbit_mq_target(configuration: &configuration::Configuration, update_rabbit_mq_target: models::UpdateRabbitMqTarget) -> Result<models::UpdateRabbitMqTargetOutput, Error<UpdateRabbitMqTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_rabbit_mq_target = update_rabbit_mq_target;

    let uri_str = format!("{}/update-rabbitmq-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_rabbit_mq_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateRabbitMqTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateRabbitMqTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateRabbitMqTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_rabbit_mq_target_details(configuration: &configuration::Configuration, update_rabbit_mq_target_details: models::UpdateRabbitMqTargetDetails) -> Result<models::UpdateTargetOutput, Error<UpdateRabbitMqTargetDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_rabbit_mq_target_details = update_rabbit_mq_target_details;

    let uri_str = format!("{}/update-rabbitmq-target-details", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_rabbit_mq_target_details);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateRabbitMqTargetDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_rdp_target_details(configuration: &configuration::Configuration, update_rdp_target_details: models::UpdateRdpTargetDetails) -> Result<models::UpdateTargetOutput, Error<UpdateRdpTargetDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_rdp_target_details = update_rdp_target_details;

    let uri_str = format!("{}/update-rdp-target-details", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_rdp_target_details);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateRdpTargetDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_role(configuration: &configuration::Configuration, update_role: models::UpdateRole) -> Result<models::UpdateRoleOutput, Error<UpdateRoleError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_role = update_role;

    let uri_str = format!("{}/update-role", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_role);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateRoleOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateRoleOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateRoleError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_rotated_secret(configuration: &configuration::Configuration, update_rotated_secret: models::UpdateRotatedSecret) -> Result<models::UpdateRotatedSecretOutput, Error<UpdateRotatedSecretError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_rotated_secret = update_rotated_secret;

    let uri_str = format!("{}/update-rotated-secret", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_rotated_secret);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateRotatedSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateRotatedSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateRotatedSecretError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_rotation_settings(configuration: &configuration::Configuration, update_rotation_settings: models::UpdateRotationSettings) -> Result<models::RotateKeyOutput, Error<UpdateRotationSettingsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_rotation_settings = update_rotation_settings;

    let uri_str = format!("{}/update-rotation-settings", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_rotation_settings);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::RotateKeyOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::RotateKeyOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateRotationSettingsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_salesforce_target(configuration: &configuration::Configuration, update_salesforce_target: models::UpdateSalesforceTarget) -> Result<models::UpdateSalesforceTargetOutput, Error<UpdateSalesforceTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_salesforce_target = update_salesforce_target;

    let uri_str = format!("{}/update-salesforce-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_salesforce_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateSalesforceTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateSalesforceTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSalesforceTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_secret_val(configuration: &configuration::Configuration, update_secret_val: models::UpdateSecretVal) -> Result<models::UpdateSecretValOutput, Error<UpdateSecretValError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_secret_val = update_secret_val;

    let uri_str = format!("{}/update-secret-val", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_secret_val);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateSecretValOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateSecretValOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSecretValError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_ssh_cert_issuer(configuration: &configuration::Configuration, update_ssh_cert_issuer: models::UpdateSshCertIssuer) -> Result<models::UpdateSshCertIssuerOutput, Error<UpdateSshCertIssuerError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_ssh_cert_issuer = update_ssh_cert_issuer;

    let uri_str = format!("{}/update-ssh-cert-issuer", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_ssh_cert_issuer);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateSshCertIssuerOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateSshCertIssuerOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSshCertIssuerError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_ssh_target(configuration: &configuration::Configuration, update_ssh_target: models::UpdateSshTarget) -> Result<models::UpdateSshTargetOutput, Error<UpdateSshTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_ssh_target = update_ssh_target;

    let uri_str = format!("{}/update-ssh-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_ssh_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateSshTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateSshTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSshTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_ssh_target_details(configuration: &configuration::Configuration, update_ssh_target_details: models::UpdateSshTargetDetails) -> Result<models::UpdateTargetOutput, Error<UpdateSshTargetDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_ssh_target_details = update_ssh_target_details;

    let uri_str = format!("{}/update-ssh-target-details", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_ssh_target_details);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateSshTargetDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_target(configuration: &configuration::Configuration, update_target: models::UpdateTarget) -> Result<models::UpdateTargetOutput, Error<UpdateTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_target = update_target;

    let uri_str = format!("{}/update-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_target_details(configuration: &configuration::Configuration, update_target_details: models::UpdateTargetDetails) -> Result<models::UpdateTargetOutput, Error<UpdateTargetDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_target_details = update_target_details;

    let uri_str = format!("{}/update-target-details", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_target_details);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateTargetDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_web_target(configuration: &configuration::Configuration, update_web_target: models::UpdateWebTarget) -> Result<models::UpdateWebTargetOutput, Error<UpdateWebTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_web_target = update_web_target;

    let uri_str = format!("{}/update-web-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_web_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateWebTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateWebTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateWebTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_web_target_details(configuration: &configuration::Configuration, update_web_target_details: models::UpdateWebTargetDetails) -> Result<models::UpdateTargetOutput, Error<UpdateWebTargetDetailsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_web_target_details = update_web_target_details;

    let uri_str = format!("{}/update-web-target-details", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_web_target_details);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateWebTargetDetailsError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_windows_target(configuration: &configuration::Configuration, update_windows_target: models::UpdateWindowsTarget) -> Result<serde_json::Value, Error<UpdateWindowsTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_windows_target = update_windows_target;

    let uri_str = format!("{}/update-windows-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_windows_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateWindowsTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn update_zero_ssl_target(configuration: &configuration::Configuration, update_zero_ssl_target: models::UpdateZeroSslTarget) -> Result<models::UpdateZeroSslTargetOutput, Error<UpdateZeroSslTargetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_update_zero_ssl_target = update_zero_ssl_target;

    let uri_str = format!("{}/update-zerossl-target", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_update_zero_ssl_target);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UpdateZeroSslTargetOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UpdateZeroSslTargetOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UpdateZeroSslTargetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn upload_rsa(configuration: &configuration::Configuration, upload_rsa: models::UploadRsa) -> Result<serde_json::Value, Error<UploadRsaError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_upload_rsa = upload_rsa;

    let uri_str = format!("{}/upload-rsa", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_upload_rsa);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UploadRsaError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn usc_create(configuration: &configuration::Configuration, usc_create: models::UscCreate) -> Result<models::UscCreateSecretOutput, Error<UscCreateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_usc_create = usc_create;

    let uri_str = format!("{}/usc-create", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_usc_create);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UscCreateSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UscCreateSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UscCreateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn usc_delete(configuration: &configuration::Configuration, usc_delete: models::UscDelete) -> Result<models::UscDeleteSecretOutput, Error<UscDeleteError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_usc_delete = usc_delete;

    let uri_str = format!("{}/usc-delete", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_usc_delete);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UscDeleteSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UscDeleteSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UscDeleteError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn usc_get(configuration: &configuration::Configuration, usc_get: models::UscGet) -> Result<models::UscGetSecretOutput, Error<UscGetError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_usc_get = usc_get;

    let uri_str = format!("{}/usc-get", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_usc_get);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UscGetSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UscGetSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UscGetError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn usc_list(configuration: &configuration::Configuration, usc_list: models::UscList) -> Result<models::UscListSecretsOutput, Error<UscListError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_usc_list = usc_list;

    let uri_str = format!("{}/usc-list", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_usc_list);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UscListSecretsOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UscListSecretsOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UscListError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn usc_update(configuration: &configuration::Configuration, usc_update: models::UscUpdate) -> Result<models::UscUpdateSecretOutput, Error<UscUpdateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_usc_update = usc_update;

    let uri_str = format!("{}/usc-update", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_usc_update);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::UscUpdateSecretOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::UscUpdateSecretOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<UscUpdateError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn validate_certificate_challenge(configuration: &configuration::Configuration, validate_certificate_challenge: models::ValidateCertificateChallenge) -> Result<models::ValidateCertificateChallengeOutput, Error<ValidateCertificateChallengeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_validate_certificate_challenge = validate_certificate_challenge;

    let uri_str = format!("{}/validate-certificate-challenge", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_validate_certificate_challenge);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ValidateCertificateChallengeOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ValidateCertificateChallengeOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ValidateCertificateChallengeError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn validate_token(configuration: &configuration::Configuration, validate_token: models::ValidateToken) -> Result<models::ValidateTokenOutput, Error<ValidateTokenError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_validate_token = validate_token;

    let uri_str = format!("{}/validate-token", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_validate_token);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::ValidateTokenOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::ValidateTokenOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<ValidateTokenError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn vault_address(configuration: &configuration::Configuration, vault_address: models::VaultAddress) -> Result<models::VaultAddressOutput, Error<VaultAddressError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_vault_address = vault_address;

    let uri_str = format!("{}/vault-address", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_vault_address);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::VaultAddressOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::VaultAddressOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<VaultAddressError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn verify_data_with_classic_key(configuration: &configuration::Configuration, verify_data_with_classic_key: models::VerifyDataWithClassicKey) -> Result<models::VerifyPkiCertOutput, Error<VerifyDataWithClassicKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_verify_data_with_classic_key = verify_data_with_classic_key;

    let uri_str = format!("{}/verify-data-with-classic-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_verify_data_with_classic_key);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::VerifyPkiCertOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::VerifyPkiCertOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<VerifyDataWithClassicKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn verify_ec_dsa(configuration: &configuration::Configuration, verify_ec_dsa: models::VerifyEcDsa) -> Result<serde_json::Value, Error<VerifyEcDsaError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_verify_ec_dsa = verify_ec_dsa;

    let uri_str = format!("{}/verify-ecdsa", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_verify_ec_dsa);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<VerifyEcDsaError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn verify_gpg(configuration: &configuration::Configuration, verify_gpg: models::VerifyGpg) -> Result<serde_json::Value, Error<VerifyGpgError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_verify_gpg = verify_gpg;

    let uri_str = format!("{}/verify-gpg", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_verify_gpg);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<VerifyGpgError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn verify_jwt_with_classic_key(configuration: &configuration::Configuration, verify_jwt_with_classic_key: models::VerifyJwtWithClassicKey) -> Result<models::VerifyJwtOutput, Error<VerifyJwtWithClassicKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_verify_jwt_with_classic_key = verify_jwt_with_classic_key;

    let uri_str = format!("{}/verify-jwt-with-classic-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_verify_jwt_with_classic_key);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::VerifyJwtOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::VerifyJwtOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<VerifyJwtWithClassicKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn verify_pkcs1(configuration: &configuration::Configuration, verify_pkcs1: models::VerifyPkcs1) -> Result<serde_json::Value, Error<VerifyPkcs1Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_verify_pkcs1 = verify_pkcs1;

    let uri_str = format!("{}/verify-pkcs1", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_verify_pkcs1);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<VerifyPkcs1Error> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn verify_pki_cert_with_classic_key(configuration: &configuration::Configuration, verify_pki_cert_with_classic_key: models::VerifyPkiCertWithClassicKey) -> Result<models::VerifyPkiCertOutput, Error<VerifyPkiCertWithClassicKeyError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_verify_pki_cert_with_classic_key = verify_pki_cert_with_classic_key;

    let uri_str = format!("{}/verify-pki-cert-with-classic-key", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_verify_pki_cert_with_classic_key);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `models::VerifyPkiCertOutput`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `models::VerifyPkiCertOutput`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<VerifyPkiCertWithClassicKeyError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}

pub async fn verify_rsa_ssa_pss(configuration: &configuration::Configuration, verify_rsa_ssa_pss: models::VerifyRsaSsaPss) -> Result<serde_json::Value, Error<VerifyRsaSsaPssError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_verify_rsa_ssa_pss = verify_rsa_ssa_pss;

    let uri_str = format!("{}/verify-rsassa-pss", configuration.base_path);
    let mut req_builder = configuration.client.request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    req_builder = req_builder.json(&p_body_verify_rsa_ssa_pss);

    let req = req_builder.build()?;
    let resp = configuration.client.execute(req).await?;

    let status = resp.status();
    let content_type = resp
        .headers()
        .get("content-type")
        .and_then(|v| v.to_str().ok())
        .unwrap_or("application/octet-stream");
    let content_type = super::ContentType::from(content_type);

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_err(Error::from),
            ContentType::Text => return Err(Error::from(serde_json::Error::custom("Received `text/plain` content type response that cannot be converted to `serde_json::Value`"))),
            ContentType::Unsupported(unknown_type) => return Err(Error::from(serde_json::Error::custom(format!("Received `{unknown_type}` content type response that cannot be converted to `serde_json::Value`")))),
        }
    } else {
        let content = resp.text().await?;
        let entity: Option<VerifyRsaSsaPssError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent { status, content, entity }))
    }
}