rusty_falcon 0.7.1

/*
 * CrowdStrike API Specification
 *
 * Use this API specification as a reference for the API endpoints you can use to interact with your Falcon environment. These endpoints support authentication via OAuth2 and interact with detections and network containment. For detailed usage guides and examples, see our [documentation inside the Falcon console](https://falcon.crowdstrike.com/support/documentation).     To use the APIs described below, combine the base URL with the path shown for each API endpoint. For commercial cloud customers, your base URL is `https://api.crowdstrike.com`.    Each API endpoint requires authorization via an OAuth2 token. Your first API request should retrieve an OAuth2 token using the `oauth2/token` endpoint, such as `https://api.crowdstrike.com/oauth2/token`. For subsequent requests, include the OAuth2 token in an HTTP authorization header. Tokens expire after 30 minutes, after which you should make a new token request to continue making API requests.
 *
 * The version of the OpenAPI document: rolling
 *
 * Generated by: https://openapi-generator.tech
 */

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

/// struct for typed errors of method [`create_aws_account`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateAwsAccountError {
    Status400(models::K8sregCreateAwsAccResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregCreateAwsAccResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`create_azure_subscription`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum CreateAzureSubscriptionError {
    Status400(models::MsaBaseEntitiesResponse),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::MsaBaseEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_aws_accounts_mixin0`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteAwsAccountsMixin0Error {
    Status400(models::MsaspecMetaInfo),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::MsaspecMetaInfo),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`delete_azure_subscription`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum DeleteAzureSubscriptionError {
    Status400(models::MsaBaseEntitiesResponse),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::MsaBaseEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`find_containers_by_container_run_time_version`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FindContainersByContainerRunTimeVersionError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`find_containers_count_affected_by_zero_day_vulnerabilities`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum FindContainersCountAffectedByZeroDayVulnerabilitiesError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_aws_accounts_mixin0`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAwsAccountsMixin0Error {
    Status400(models::K8sregGetAwsAccountsResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregGetAwsAccountsResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_azure_install_script`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAzureInstallScriptError {
    Status400(models::K8sregGetAzureBashScriptResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregGetAzureBashScriptResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_azure_tenant_config`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAzureTenantConfigError {
    Status400(models::K8sregGetAzureTenantConfigResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregGetAzureTenantConfigResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_azure_tenant_ids`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetAzureTenantIdsError {
    Status400(models::K8sregGetAzureTenantInfoResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregGetAzureTenantInfoResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_clusters`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetClustersError {
    Status400(models::K8sregGetClustersResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregGetClustersResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_combined_cloud_clusters`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetCombinedCloudClustersError {
    Status400(models::K8sregListClusterCloudResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregListClusterCloudResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_helm_values_yaml`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetHelmValuesYamlError {
    Status400(models::MsaReplyMetaOnly),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::MsaReplyMetaOnly),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_locations`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetLocationsError {
    Status400(models::K8sregGetLocationsResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregGetLocationsResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`get_static_scripts`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GetStaticScriptsError {
    Status400(models::K8sregGetScriptsResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregGetScriptsResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`group_containers_by_managed`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum GroupContainersByManagedError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`list_azure_accounts`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ListAzureAccountsError {
    Status400(models::K8sregGetAzureSubscriptionsResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregGetAzureSubscriptionsResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`patch_azure_service_principal`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PatchAzureServicePrincipalError {
    Status400(models::K8sregGetAzureTenantConfigResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregGetAzureTenantConfigResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`post_search_kubernetes_iom_entities`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum PostSearchKubernetesIomEntitiesError {
    Status400(models::CoreEntitiesResponse),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_cluster_combined`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadClusterCombinedError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_cluster_combined_v2`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadClusterCombinedV2Error {
    Status400(models::CoreEntitiesResponse),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_cluster_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadClusterCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_cluster_enrichment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadClusterEnrichmentError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_clusters_by_date_range_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadClustersByDateRangeCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_clusters_by_kubernetes_version_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadClustersByKubernetesVersionCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_clusters_by_status_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadClustersByStatusCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_container_combined`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadContainerCombinedError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_container_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadContainerCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_container_count_by_registry`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadContainerCountByRegistryError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_container_enrichment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadContainerEnrichmentError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_container_image_detections_count_by_date`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadContainerImageDetectionsCountByDateError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_container_images_by_most_used`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadContainerImagesByMostUsedError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_container_images_by_state`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadContainerImagesByStateError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_container_vulnerabilities_by_severity_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadContainerVulnerabilitiesBySeverityCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_containers_by_date_range_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadContainersByDateRangeCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_containers_sensor_coverage`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadContainersSensorCoverageError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_deployment_combined`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadDeploymentCombinedError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_deployment_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadDeploymentCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_deployment_enrichment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadDeploymentEnrichmentError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_deployments_by_date_range_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadDeploymentsByDateRangeCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_distinct_container_image_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadDistinctContainerImageCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_kubernetes_iom_by_date_range`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadKubernetesIomByDateRangeError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_kubernetes_iom_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadKubernetesIomCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_kubernetes_iom_entities`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadKubernetesIomEntitiesError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_namespace_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadNamespaceCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_namespaces_by_date_range_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadNamespacesByDateRangeCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_node_combined`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadNodeCombinedError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_node_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadNodeCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_node_enrichment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadNodeEnrichmentError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_nodes_by_cloud_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadNodesByCloudCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_nodes_by_container_engine_version_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadNodesByContainerEngineVersionCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_nodes_by_date_range_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadNodesByDateRangeCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_pod_combined`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadPodCombinedError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_pod_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadPodCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_pod_enrichment`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadPodEnrichmentError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_pods_by_date_range_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadPodsByDateRangeCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_running_container_images`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadRunningContainerImagesError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`read_vulnerable_container_image_count`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum ReadVulnerableContainerImageCountError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`regenerate_api_key`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum RegenerateApiKeyError {
    Status400(models::K8sregRegenApiKeyResp),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::K8sregRegenApiKeyResp),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`search_and_read_kubernetes_iom_entities`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SearchAndReadKubernetesIomEntitiesError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`search_kubernetes_ioms`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum SearchKubernetesIomsError {
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::CoreEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`trigger_scan`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum TriggerScanError {
    Status400(models::MsaBaseEntitiesResponse),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::MsaBaseEntitiesResponse),
    UnknownValue(serde_json::Value),
}

/// struct for typed errors of method [`update_aws_account`]
#[derive(Debug, Clone, Serialize, Deserialize)]
#[serde(untagged)]
pub enum UpdateAwsAccountError {
    Status400(models::MsaBaseEntitiesResponse),
    Status403(models::MsaReplyMetaOnly),
    Status429(models::MsaReplyMetaOnly),
    Status500(models::MsaBaseEntitiesResponse),
    UnknownValue(serde_json::Value),
}

pub async fn create_aws_account(
    configuration: &configuration::Configuration,
    body: models::K8sregCreateAwsAccReq,
) -> Result<models::K8sregCreateAwsAccResp, Error<CreateAwsAccountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_body = body;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/accounts/aws/v1",
        configuration.base_path
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_body);

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

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

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

pub async fn create_azure_subscription(
    configuration: &configuration::Configuration,
    body: models::K8sregCreateAzureSubReq,
) -> Result<models::MsaBaseEntitiesResponse, Error<CreateAzureSubscriptionError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_body = body;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/accounts/azure/v1",
        configuration.base_path
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_body);

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

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

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

pub async fn delete_aws_accounts_mixin0(
    configuration: &configuration::Configuration,
    ids: Vec<String>,
) -> Result<models::MsaspecMetaInfo, Error<DeleteAwsAccountsMixin0Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_ids = ids;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/accounts/aws/v1",
        configuration.base_path
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    req_builder = match "csv" {
        "multi" => req_builder.query(
            &p_query_ids
                .into_iter()
                .map(|p| ("ids".to_owned(), p.to_string()))
                .collect::<Vec<(std::string::String, std::string::String)>>(),
        ),
        _ => req_builder.query(&[(
            "ids",
            &p_query_ids
                .into_iter()
                .map(|p| p.to_string())
                .collect::<Vec<String>>()
                .join(",")
                .to_string(),
        )]),
    };
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn delete_azure_subscription(
    configuration: &configuration::Configuration,
    ids: Option<Vec<String>>,
) -> Result<models::MsaBaseEntitiesResponse, Error<DeleteAzureSubscriptionError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_ids = ids;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/accounts/azure/v1",
        configuration.base_path
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::DELETE, &uri_str);

    if let Some(ref param_value) = p_query_ids {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("ids".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "ids",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn find_containers_by_container_run_time_version(
    configuration: &configuration::Configuration,
    limit: Option<i32>,
    offset: Option<i32>,
    sort: Option<&str>,
    filter: Option<&str>,
) -> Result<
    models::ModelsContainerRuntimePivotResponse,
    Error<FindContainersByContainerRunTimeVersionError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_limit = limit;
    let p_query_offset = offset;
    let p_query_sort = sort;
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/containers/find-by-runtimeversion/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn find_containers_count_affected_by_zero_day_vulnerabilities(
    configuration: &configuration::Configuration,
) -> Result<
    models::CommonCountResponse,
    Error<FindContainersCountAffectedByZeroDayVulnerabilitiesError>,
> {
    let uri_str = format!(
        "{}/container-security/aggregates/containers/count-by-zero-day/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn get_aws_accounts_mixin0(
    configuration: &configuration::Configuration,
    ids: Option<Vec<String>>,
    is_horizon_acct: Option<&str>,
    status: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::K8sregGetAwsAccountsResp, Error<GetAwsAccountsMixin0Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_ids = ids;
    let p_query_is_horizon_acct = is_horizon_acct;
    let p_query_status = status;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/accounts/aws/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_ids {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("ids".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "ids",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_is_horizon_acct {
        req_builder = req_builder.query(&[("is_horizon_acct", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_status {
        req_builder = req_builder.query(&[("status", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn get_azure_install_script(
    configuration: &configuration::Configuration,
    id: Option<&str>,
    subscription_id: Option<Vec<String>>,
) -> Result<models::K8sregGetAzureBashScriptResp, Error<GetAzureInstallScriptError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_id = id;
    let p_query_subscription_id = subscription_id;

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

    if let Some(ref param_value) = p_query_id {
        req_builder = req_builder.query(&[("id", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_subscription_id {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("subscription_id".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "subscription_id",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn get_azure_tenant_config(
    configuration: &configuration::Configuration,
    ids: Option<Vec<String>>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::K8sregGetAzureTenantConfigResp, Error<GetAzureTenantConfigError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_ids = ids;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/config/azure/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_ids {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("ids".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "ids",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn get_azure_tenant_ids(
    configuration: &configuration::Configuration,
    ids: Option<Vec<String>>,
    status: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::K8sregGetAzureTenantInfoResp, Error<GetAzureTenantIdsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_ids = ids;
    let p_query_status = status;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/tenants/azure/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_ids {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("ids".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "ids",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_status {
        req_builder = req_builder.query(&[("status", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn get_clusters(
    configuration: &configuration::Configuration,
    cluster_names: Option<Vec<String>>,
    status: Option<Vec<String>>,
    account_ids: Option<Vec<String>>,
    locations: Option<Vec<String>>,
    cluster_service: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::K8sregGetClustersResp, Error<GetClustersError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_cluster_names = cluster_names;
    let p_query_status = status;
    let p_query_account_ids = account_ids;
    let p_query_locations = locations;
    let p_query_cluster_service = cluster_service;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/kubernetes/clusters/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_cluster_names {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("cluster_names".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "cluster_names",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_status {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("status".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "status",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_account_ids {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("account_ids".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "account_ids",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_locations {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("locations".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "locations",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_cluster_service {
        req_builder = req_builder.query(&[("cluster_service", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn get_combined_cloud_clusters(
    configuration: &configuration::Configuration,
    locations: Option<Vec<String>>,
    ids: Option<Vec<String>>,
    cluster_service: Option<Vec<String>>,
    cluster_status: Option<Vec<String>>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::K8sregListClusterCloudResp, Error<GetCombinedCloudClustersError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_locations = locations;
    let p_query_ids = ids;
    let p_query_cluster_service = cluster_service;
    let p_query_cluster_status = cluster_status;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/cloud_cluster/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_locations {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("locations".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "locations",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_ids {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("ids".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "ids",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_cluster_service {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("cluster_service".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "cluster_service",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_cluster_status {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("cluster_status".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "cluster_status",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn get_helm_values_yaml(
    configuration: &configuration::Configuration,
    cluster_name: &str,
    is_self_managed_cluster: Option<bool>,
) -> Result<serde_json::Value, Error<GetHelmValuesYamlError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_cluster_name = cluster_name;
    let p_query_is_self_managed_cluster = is_self_managed_cluster;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/integration/agent/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = req_builder.query(&[("cluster_name", &p_query_cluster_name.to_string())]);
    if let Some(ref param_value) = p_query_is_self_managed_cluster {
        req_builder = req_builder.query(&[("is_self_managed_cluster", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

    if !status.is_client_error() && !status.is_server_error() {
        let content = resp.text().await?;
        match content_type {
            ContentType::Json => serde_json::from_str(&content).map_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<GetHelmValuesYamlError> = serde_json::from_str(&content).ok();
        Err(Error::ResponseError(ResponseContent {
            status,
            content,
            entity,
        }))
    }
}

pub async fn get_locations(
    configuration: &configuration::Configuration,
    clouds: Option<Vec<String>>,
) -> Result<models::K8sregGetLocationsResp, Error<GetLocationsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_clouds = clouds;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/cloud-locations/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_clouds {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("clouds".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "clouds",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn get_static_scripts(
    configuration: &configuration::Configuration,
) -> Result<models::K8sregGetScriptsResp, Error<GetStaticScriptsError>> {
    let uri_str = format!(
        "{}/kubernetes-protection/entities/gen/scripts/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn group_containers_by_managed(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::ModelsContainerCoverageResponseEntity, Error<GroupContainersByManagedError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/containers/group-by-managed/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn list_azure_accounts(
    configuration: &configuration::Configuration,
    ids: Option<Vec<String>>,
    subscription_id: Option<Vec<String>>,
    status: Option<&str>,
    is_horizon_acct: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::K8sregGetAzureSubscriptionsResp, Error<ListAzureAccountsError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_ids = ids;
    let p_query_subscription_id = subscription_id;
    let p_query_status = status;
    let p_query_is_horizon_acct = is_horizon_acct;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/accounts/azure/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_ids {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("ids".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "ids",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_subscription_id {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("subscription_id".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "subscription_id",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref param_value) = p_query_status {
        req_builder = req_builder.query(&[("status", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_is_horizon_acct {
        req_builder = req_builder.query(&[("is_horizon_acct", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn patch_azure_service_principal(
    configuration: &configuration::Configuration,
    id: &str,
    client_id: &str,
) -> Result<models::K8sregGetAzureTenantConfigResp, Error<PatchAzureServicePrincipalError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_id = id;
    let p_query_client_id = client_id;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/service-principal/azure/v1",
        configuration.base_path
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    req_builder = req_builder.query(&[("id", &p_query_id.to_string())]);
    req_builder = req_builder.query(&[("client_id", &p_query_client_id.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn post_search_kubernetes_iom_entities(
    configuration: &configuration::Configuration,
    body: models::K8siomsSearchRequest,
    filter: Option<&str>,
    sort: Option<&str>,
    limit: Option<i32>,
) -> Result<models::K8siomsSearchResponse, Error<PostSearchKubernetesIomEntitiesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_body_body = body;
    let p_query_filter = filter;
    let p_query_sort = sort;
    let p_query_limit = limit;

    let uri_str = format!(
        "{}/container-security/combined/kubernetes-ioms/search/v1",
        configuration.base_path
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };
    req_builder = req_builder.json(&p_body_body);

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

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

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

pub async fn read_cluster_combined(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
    sort: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::ModelsClusterEntityResponse, Error<ReadClusterCombinedError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;
    let p_query_sort = sort;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/container-security/combined/clusters/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_cluster_combined_v2(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
    sort: Option<&str>,
    include_counts: Option<bool>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::V2ClusterEntityResponseV2, Error<ReadClusterCombinedV2Error>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;
    let p_query_sort = sort;
    let p_query_include_counts = include_counts;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/container-security/combined/clusters/v2",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_include_counts {
        req_builder = req_builder.query(&[("include_counts", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_cluster_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::CommonCountResponse, Error<ReadClusterCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/clusters/count/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_cluster_enrichment(
    configuration: &configuration::Configuration,
    cluster_id: Vec<String>,
    filter: Option<&str>,
) -> Result<models::K8sassetsClusterEnrichmentResponse, Error<ReadClusterEnrichmentError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_cluster_id = cluster_id;
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/enrichment/clusters/entities/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = match "csv" {
        "multi" => req_builder.query(
            &p_query_cluster_id
                .into_iter()
                .map(|p| ("cluster_id".to_owned(), p.to_string()))
                .collect::<Vec<(std::string::String, std::string::String)>>(),
        ),
        _ => req_builder.query(&[(
            "cluster_id",
            &p_query_cluster_id
                .into_iter()
                .map(|p| p.to_string())
                .collect::<Vec<String>>()
                .join(",")
                .to_string(),
        )]),
    };
    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_clusters_by_date_range_count(
    configuration: &configuration::Configuration,
) -> Result<models::ModelsAggregateValuesByFieldResponse, Error<ReadClustersByDateRangeCountError>>
{
    let uri_str = format!(
        "{}/container-security/aggregates/clusters/count-by-date/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_clusters_by_kubernetes_version_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<
    models::ModelsAggregateValuesByFieldResponse,
    Error<ReadClustersByKubernetesVersionCountError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/clusters/count-by-kubernetes-version/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_clusters_by_status_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::ModelsAggregateValuesByFieldResponse, Error<ReadClustersByStatusCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/clusters/count-by-status/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_container_combined(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
    sort: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::ModelsContainerEntityResponse, Error<ReadContainerCombinedError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;
    let p_query_sort = sort;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/container-security/combined/containers/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_container_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::CommonCountResponse, Error<ReadContainerCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/containers/count/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_container_count_by_registry(
    configuration: &configuration::Configuration,
    under_assessment: Option<bool>,
    limit: Option<i32>,
    filter: Option<&str>,
) -> Result<models::ModelsApiFilterResponse, Error<ReadContainerCountByRegistryError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_under_assessment = under_assessment;
    let p_query_limit = limit;
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/containers/count-by-registry/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_under_assessment {
        req_builder = req_builder.query(&[("under_assessment", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_container_enrichment(
    configuration: &configuration::Configuration,
    container_id: Vec<String>,
    filter: Option<&str>,
) -> Result<models::K8sassetsContainerEnrichmentResponse, Error<ReadContainerEnrichmentError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_container_id = container_id;
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/enrichment/containers/entities/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = match "csv" {
        "multi" => req_builder.query(
            &p_query_container_id
                .into_iter()
                .map(|p| ("container_id".to_owned(), p.to_string()))
                .collect::<Vec<(std::string::String, std::string::String)>>(),
        ),
        _ => req_builder.query(&[(
            "container_id",
            &p_query_container_id
                .into_iter()
                .map(|p| p.to_string())
                .collect::<Vec<String>>()
                .join(",")
                .to_string(),
        )]),
    };
    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_container_image_detections_count_by_date(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::ModelsApiFilterResponse, Error<ReadContainerImageDetectionsCountByDateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/containers/image-detections-count-by-date/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_container_images_by_most_used(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::ModelsAggregateValuesByFieldResponse, Error<ReadContainerImagesByMostUsedError>>
{
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/images/most-used/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_container_images_by_state(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::ModelsApiFilterResponse, Error<ReadContainerImagesByStateError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/containers/images-by-state/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_container_vulnerabilities_by_severity_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<
    models::ModelsAggregateValuesByFieldResponse,
    Error<ReadContainerVulnerabilitiesBySeverityCountError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/containers/vulnerability-count-by-severity/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_containers_by_date_range_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::ModelsAggregateValuesByFieldResponse, Error<ReadContainersByDateRangeCountError>>
{
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/containers/count-by-date/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_containers_sensor_coverage(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::ModelsAggregateValuesByFieldResponse, Error<ReadContainersSensorCoverageError>>
{
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/containers/sensor-coverage/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_deployment_combined(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
    sort: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::ModelsDeploymentEntityResponse, Error<ReadDeploymentCombinedError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;
    let p_query_sort = sort;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/container-security/combined/deployments/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_deployment_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::CommonCountResponse, Error<ReadDeploymentCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/deployments/count/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_deployment_enrichment(
    configuration: &configuration::Configuration,
    deployment_id: Vec<String>,
    filter: Option<&str>,
) -> Result<models::K8sassetsDeploymentEnrichmentResponse, Error<ReadDeploymentEnrichmentError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_deployment_id = deployment_id;
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/enrichment/deployments/entities/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = match "csv" {
        "multi" => req_builder.query(
            &p_query_deployment_id
                .into_iter()
                .map(|p| ("deployment_id".to_owned(), p.to_string()))
                .collect::<Vec<(std::string::String, std::string::String)>>(),
        ),
        _ => req_builder.query(&[(
            "deployment_id",
            &p_query_deployment_id
                .into_iter()
                .map(|p| p.to_string())
                .collect::<Vec<String>>()
                .join(",")
                .to_string(),
        )]),
    };
    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_deployments_by_date_range_count(
    configuration: &configuration::Configuration,
) -> Result<models::ModelsAggregateValuesByFieldResponse, Error<ReadDeploymentsByDateRangeCountError>>
{
    let uri_str = format!(
        "{}/container-security/aggregates/deployments/count-by-date/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_distinct_container_image_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::ModelsApiFilterResponse, Error<ReadDistinctContainerImageCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/images/count-by-distinct/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_kubernetes_iom_by_date_range(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::K8siomsKubernetesIomFieldValue, Error<ReadKubernetesIomByDateRangeError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/kubernetes-ioms/count-by-date/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_kubernetes_iom_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::K8siomsKubernetesIomCountValue, Error<ReadKubernetesIomCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/kubernetes-ioms/count/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_kubernetes_iom_entities(
    configuration: &configuration::Configuration,
    ids: Option<Vec<String>>,
) -> Result<models::K8siomsKubernetesIomEntityResponse, Error<ReadKubernetesIomEntitiesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_ids = ids;

    let uri_str = format!(
        "{}/container-security/entities/kubernetes-ioms/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_ids {
        req_builder = match "csv" {
            "multi" => req_builder.query(
                &param_value
                    .into_iter()
                    .map(|p| ("ids".to_owned(), p.to_string()))
                    .collect::<Vec<(std::string::String, std::string::String)>>(),
            ),
            _ => req_builder.query(&[(
                "ids",
                &param_value
                    .into_iter()
                    .map(|p| p.to_string())
                    .collect::<Vec<String>>()
                    .join(",")
                    .to_string(),
            )]),
        };
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_namespace_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::CommonCountResponse, Error<ReadNamespaceCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/namespaces/count/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_namespaces_by_date_range_count(
    configuration: &configuration::Configuration,
) -> Result<models::ModelsAggregateValuesByFieldResponse, Error<ReadNamespacesByDateRangeCountError>>
{
    let uri_str = format!(
        "{}/container-security/aggregates/namespaces/count-by-date/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_node_combined(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
    sort: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::ModelsNodeEntityResponse, Error<ReadNodeCombinedError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;
    let p_query_sort = sort;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/container-security/combined/nodes/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_node_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::CommonCountResponse, Error<ReadNodeCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/nodes/count/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_node_enrichment(
    configuration: &configuration::Configuration,
    node_name: Vec<String>,
    filter: Option<&str>,
) -> Result<models::K8sassetsNodeEnrichmentResponse, Error<ReadNodeEnrichmentError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_node_name = node_name;
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/enrichment/nodes/entities/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = match "csv" {
        "multi" => req_builder.query(
            &p_query_node_name
                .into_iter()
                .map(|p| ("node_name".to_owned(), p.to_string()))
                .collect::<Vec<(std::string::String, std::string::String)>>(),
        ),
        _ => req_builder.query(&[(
            "node_name",
            &p_query_node_name
                .into_iter()
                .map(|p| p.to_string())
                .collect::<Vec<String>>()
                .join(",")
                .to_string(),
        )]),
    };
    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_nodes_by_cloud_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::ModelsAggregateValuesByFieldResponse, Error<ReadNodesByCloudCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/nodes/count-by-cloud/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_nodes_by_container_engine_version_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<
    models::ModelsAggregateValuesByFieldResponse,
    Error<ReadNodesByContainerEngineVersionCountError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/nodes/count-by-container-engine-version/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_nodes_by_date_range_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::ModelsAggregateValuesByFieldResponse, Error<ReadNodesByDateRangeCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/nodes/count-by-date/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_pod_combined(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
    sort: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::ModelsPodEntityResponse, Error<ReadPodCombinedError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;
    let p_query_sort = sort;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/container-security/combined/pods/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_pod_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::CommonCountResponse, Error<ReadPodCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/pods/count/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_pod_enrichment(
    configuration: &configuration::Configuration,
    pod_id: Vec<String>,
    filter: Option<&str>,
) -> Result<models::K8sassetsPodEnrichmentResponse, Error<ReadPodEnrichmentError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_pod_id = pod_id;
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/enrichment/pods/entities/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    req_builder = match "csv" {
        "multi" => req_builder.query(
            &p_query_pod_id
                .into_iter()
                .map(|p| ("pod_id".to_owned(), p.to_string()))
                .collect::<Vec<(std::string::String, std::string::String)>>(),
        ),
        _ => req_builder.query(&[(
            "pod_id",
            &p_query_pod_id
                .into_iter()
                .map(|p| p.to_string())
                .collect::<Vec<String>>()
                .join(",")
                .to_string(),
        )]),
    };
    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_pods_by_date_range_count(
    configuration: &configuration::Configuration,
) -> Result<models::ModelsAggregateValuesByFieldResponse, Error<ReadPodsByDateRangeCountError>> {
    let uri_str = format!(
        "{}/container-security/aggregates/pods/count-by-date/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_running_container_images(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
    sort: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<models::ModelsContainerImage, Error<ReadRunningContainerImagesError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;
    let p_query_sort = sort;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/container-security/combined/container-images/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn read_vulnerable_container_image_count(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
) -> Result<models::ModelsApiFilterResponse, Error<ReadVulnerableContainerImageCountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;

    let uri_str = format!(
        "{}/container-security/aggregates/containers/count-vulnerable-images/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn regenerate_api_key(
    configuration: &configuration::Configuration,
) -> Result<models::K8sregRegenApiKeyResp, Error<RegenerateApiKeyError>> {
    let uri_str = format!(
        "{}/kubernetes-protection/entities/integration/api-key/v1",
        configuration.base_path
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn search_and_read_kubernetes_iom_entities(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
    sort: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<
    models::K8siomsKubernetesIomEntityResponse,
    Error<SearchAndReadKubernetesIomEntitiesError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;
    let p_query_sort = sort;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/container-security/combined/kubernetes-ioms/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn search_kubernetes_ioms(
    configuration: &configuration::Configuration,
    filter: Option<&str>,
    sort: Option<&str>,
    limit: Option<i32>,
    offset: Option<i32>,
) -> Result<
    models::CommonGenericEntityResponseLeftSquareBracketStringRightSquareBracket,
    Error<SearchKubernetesIomsError>,
> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_filter = filter;
    let p_query_sort = sort;
    let p_query_limit = limit;
    let p_query_offset = offset;

    let uri_str = format!(
        "{}/container-security/queries/kubernetes-ioms/v1",
        configuration.base_path
    );
    let mut req_builder = configuration.client.request(reqwest::Method::GET, &uri_str);

    if let Some(ref param_value) = p_query_filter {
        req_builder = req_builder.query(&[("filter", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_sort {
        req_builder = req_builder.query(&[("sort", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_limit {
        req_builder = req_builder.query(&[("limit", &param_value.to_string())]);
    }
    if let Some(ref param_value) = p_query_offset {
        req_builder = req_builder.query(&[("offset", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn trigger_scan(
    configuration: &configuration::Configuration,
    scan_type: &str,
) -> Result<models::MsaBaseEntitiesResponse, Error<TriggerScanError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_scan_type = scan_type;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/scan/trigger/v1",
        configuration.base_path
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::POST, &uri_str);

    req_builder = req_builder.query(&[("scan_type", &p_query_scan_type.to_string())]);
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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

pub async fn update_aws_account(
    configuration: &configuration::Configuration,
    ids: Vec<String>,
    region: Option<&str>,
) -> Result<models::MsaBaseEntitiesResponse, Error<UpdateAwsAccountError>> {
    // add a prefix to parameters to efficiently prevent name collisions
    let p_query_ids = ids;
    let p_query_region = region;

    let uri_str = format!(
        "{}/kubernetes-protection/entities/accounts/aws/v1",
        configuration.base_path
    );
    let mut req_builder = configuration
        .client
        .request(reqwest::Method::PATCH, &uri_str);

    req_builder = match "csv" {
        "multi" => req_builder.query(
            &p_query_ids
                .into_iter()
                .map(|p| ("ids".to_owned(), p.to_string()))
                .collect::<Vec<(std::string::String, std::string::String)>>(),
        ),
        _ => req_builder.query(&[(
            "ids",
            &p_query_ids
                .into_iter()
                .map(|p| p.to_string())
                .collect::<Vec<String>>()
                .join(",")
                .to_string(),
        )]),
    };
    if let Some(ref param_value) = p_query_region {
        req_builder = req_builder.query(&[("region", &param_value.to_string())]);
    }
    if let Some(ref user_agent) = configuration.user_agent {
        req_builder = req_builder.header(reqwest::header::USER_AGENT, user_agent.clone());
    }
    if let Some(ref token) = configuration.oauth_access_token {
        req_builder = req_builder.bearer_auth(token.to_owned());
    };

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

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

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