use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl LicenseManagerClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request =
SignedRequest::new(http_method, "license-manager", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AutomatedDiscoveryInformation {
#[serde(rename = "LastRunTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_run_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConsumedLicenseSummary {
#[serde(rename = "ConsumedLicenses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consumed_licenses: Option<i64>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLicenseConfigurationRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LicenseCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_count: Option<i64>,
#[serde(rename = "LicenseCountHardLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_count_hard_limit: Option<bool>,
#[serde(rename = "LicenseCountingType")]
pub license_counting_type: String,
#[serde(rename = "LicenseRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_rules: Option<Vec<String>>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "ProductInformationList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_information_list: Option<Vec<ProductInformation>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLicenseConfigurationResponse {
#[serde(rename = "LicenseConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_configuration_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLicenseConfigurationRequest {
#[serde(rename = "LicenseConfigurationArn")]
pub license_configuration_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteLicenseConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Filter {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Values")]
#[serde(skip_serializing_if = "Option::is_none")]
pub values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLicenseConfigurationRequest {
#[serde(rename = "LicenseConfigurationArn")]
pub license_configuration_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLicenseConfigurationResponse {
#[serde(rename = "AutomatedDiscoveryInformation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub automated_discovery_information: Option<AutomatedDiscoveryInformation>,
#[serde(rename = "ConsumedLicenseSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consumed_license_summary_list: Option<Vec<ConsumedLicenseSummary>>,
#[serde(rename = "ConsumedLicenses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consumed_licenses: Option<i64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LicenseConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_configuration_arn: Option<String>,
#[serde(rename = "LicenseConfigurationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_configuration_id: Option<String>,
#[serde(rename = "LicenseCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_count: Option<i64>,
#[serde(rename = "LicenseCountHardLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_count_hard_limit: Option<bool>,
#[serde(rename = "LicenseCountingType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_counting_type: Option<String>,
#[serde(rename = "LicenseRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_rules: Option<Vec<String>>,
#[serde(rename = "ManagedResourceSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub managed_resource_summary_list: Option<Vec<ManagedResourceSummary>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "OwnerAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_account_id: Option<String>,
#[serde(rename = "ProductInformationList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_information_list: Option<Vec<ProductInformation>>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetServiceSettingsRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetServiceSettingsResponse {
#[serde(rename = "EnableCrossAccountsDiscovery")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_cross_accounts_discovery: Option<bool>,
#[serde(rename = "LicenseManagerResourceShareArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_manager_resource_share_arn: Option<String>,
#[serde(rename = "OrganizationConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_configuration: Option<OrganizationConfiguration>,
#[serde(rename = "S3BucketArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_bucket_arn: Option<String>,
#[serde(rename = "SnsTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InventoryFilter {
#[serde(rename = "Condition")]
pub condition: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LicenseConfiguration {
#[serde(rename = "AutomatedDiscoveryInformation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub automated_discovery_information: Option<AutomatedDiscoveryInformation>,
#[serde(rename = "ConsumedLicenseSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consumed_license_summary_list: Option<Vec<ConsumedLicenseSummary>>,
#[serde(rename = "ConsumedLicenses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consumed_licenses: Option<i64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LicenseConfigurationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_configuration_arn: Option<String>,
#[serde(rename = "LicenseConfigurationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_configuration_id: Option<String>,
#[serde(rename = "LicenseCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_count: Option<i64>,
#[serde(rename = "LicenseCountHardLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_count_hard_limit: Option<bool>,
#[serde(rename = "LicenseCountingType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_counting_type: Option<String>,
#[serde(rename = "LicenseRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_rules: Option<Vec<String>>,
#[serde(rename = "ManagedResourceSummaryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub managed_resource_summary_list: Option<Vec<ManagedResourceSummary>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "OwnerAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner_account_id: Option<String>,
#[serde(rename = "ProductInformationList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_information_list: Option<Vec<ProductInformation>>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LicenseConfigurationAssociation {
#[serde(rename = "AssociationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_time: Option<f64>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceOwnerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_owner_id: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LicenseConfigurationUsage {
#[serde(rename = "AssociationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_time: Option<f64>,
#[serde(rename = "ConsumedLicenses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consumed_licenses: Option<i64>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceOwnerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_owner_id: Option<String>,
#[serde(rename = "ResourceStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_status: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LicenseOperationFailure {
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "FailureTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_time: Option<f64>,
#[serde(rename = "MetadataList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub metadata_list: Option<Vec<Metadata>>,
#[serde(rename = "OperationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_name: Option<String>,
#[serde(rename = "OperationRequestedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_requested_by: Option<String>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceOwnerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_owner_id: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LicenseSpecification {
#[serde(rename = "LicenseConfigurationArn")]
pub license_configuration_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAssociationsForLicenseConfigurationRequest {
#[serde(rename = "LicenseConfigurationArn")]
pub license_configuration_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAssociationsForLicenseConfigurationResponse {
#[serde(rename = "LicenseConfigurationAssociations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_configuration_associations: Option<Vec<LicenseConfigurationAssociation>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFailuresForLicenseConfigurationOperationsRequest {
#[serde(rename = "LicenseConfigurationArn")]
pub license_configuration_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFailuresForLicenseConfigurationOperationsResponse {
#[serde(rename = "LicenseOperationFailureList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_operation_failure_list: Option<Vec<LicenseOperationFailure>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLicenseConfigurationsRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "LicenseConfigurationArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_configuration_arns: Option<Vec<String>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLicenseConfigurationsResponse {
#[serde(rename = "LicenseConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_configurations: Option<Vec<LicenseConfiguration>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLicenseSpecificationsForResourceRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLicenseSpecificationsForResourceResponse {
#[serde(rename = "LicenseSpecifications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_specifications: Option<Vec<LicenseSpecification>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResourceInventoryRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<InventoryFilter>>,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResourceInventoryResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ResourceInventoryList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_inventory_list: Option<Vec<ResourceInventory>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListUsageForLicenseConfigurationRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "LicenseConfigurationArn")]
pub license_configuration_arn: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListUsageForLicenseConfigurationResponse {
#[serde(rename = "LicenseConfigurationUsageList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_configuration_usage_list: Option<Vec<LicenseConfigurationUsage>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ManagedResourceSummary {
#[serde(rename = "AssociationCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub association_count: Option<i64>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Metadata {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OrganizationConfiguration {
#[serde(rename = "EnableIntegration")]
pub enable_integration: bool,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProductInformation {
#[serde(rename = "ProductInformationFilterList")]
pub product_information_filter_list: Vec<ProductInformationFilter>,
#[serde(rename = "ResourceType")]
pub resource_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ProductInformationFilter {
#[serde(rename = "ProductInformationFilterComparator")]
pub product_information_filter_comparator: String,
#[serde(rename = "ProductInformationFilterName")]
pub product_information_filter_name: String,
#[serde(rename = "ProductInformationFilterValue")]
pub product_information_filter_value: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceInventory {
#[serde(rename = "Platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "PlatformVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform_version: Option<String>,
#[serde(rename = "ResourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_arn: Option<String>,
#[serde(rename = "ResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_id: Option<String>,
#[serde(rename = "ResourceOwningAccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_owning_account_id: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateLicenseConfigurationRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LicenseConfigurationArn")]
pub license_configuration_arn: String,
#[serde(rename = "LicenseConfigurationStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_configuration_status: Option<String>,
#[serde(rename = "LicenseCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_count: Option<i64>,
#[serde(rename = "LicenseCountHardLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_count_hard_limit: Option<bool>,
#[serde(rename = "LicenseRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_rules: Option<Vec<String>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ProductInformationList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_information_list: Option<Vec<ProductInformation>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateLicenseConfigurationResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateLicenseSpecificationsForResourceRequest {
#[serde(rename = "AddLicenseSpecifications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_license_specifications: Option<Vec<LicenseSpecification>>,
#[serde(rename = "RemoveLicenseSpecifications")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_license_specifications: Option<Vec<LicenseSpecification>>,
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateLicenseSpecificationsForResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateServiceSettingsRequest {
#[serde(rename = "EnableCrossAccountsDiscovery")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_cross_accounts_discovery: Option<bool>,
#[serde(rename = "OrganizationConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_configuration: Option<OrganizationConfiguration>,
#[serde(rename = "S3BucketArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_bucket_arn: Option<String>,
#[serde(rename = "SnsTopicArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sns_topic_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateServiceSettingsResponse {}
#[derive(Debug, PartialEq)]
pub enum CreateLicenseConfigurationError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ResourceLimitExceeded(String),
ServerInternal(String),
}
impl CreateLicenseConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateLicenseConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateLicenseConfigurationError::AccessDenied(
err.msg,
))
}
"AuthorizationException" => {
return RusotoError::Service(CreateLicenseConfigurationError::Authorization(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(
CreateLicenseConfigurationError::InvalidParameterValue(err.msg),
)
}
"RateLimitExceededException" => {
return RusotoError::Service(
CreateLicenseConfigurationError::RateLimitExceeded(err.msg),
)
}
"ResourceLimitExceededException" => {
return RusotoError::Service(
CreateLicenseConfigurationError::ResourceLimitExceeded(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(CreateLicenseConfigurationError::ServerInternal(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLicenseConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLicenseConfigurationError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateLicenseConfigurationError::Authorization(ref cause) => write!(f, "{}", cause),
CreateLicenseConfigurationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
CreateLicenseConfigurationError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateLicenseConfigurationError::ResourceLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateLicenseConfigurationError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLicenseConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLicenseConfigurationError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl DeleteLicenseConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteLicenseConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteLicenseConfigurationError::AccessDenied(
err.msg,
))
}
"AuthorizationException" => {
return RusotoError::Service(DeleteLicenseConfigurationError::Authorization(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DeleteLicenseConfigurationError::InvalidParameterValue(err.msg),
)
}
"RateLimitExceededException" => {
return RusotoError::Service(
DeleteLicenseConfigurationError::RateLimitExceeded(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(DeleteLicenseConfigurationError::ServerInternal(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLicenseConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLicenseConfigurationError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteLicenseConfigurationError::Authorization(ref cause) => write!(f, "{}", cause),
DeleteLicenseConfigurationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteLicenseConfigurationError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteLicenseConfigurationError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLicenseConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetLicenseConfigurationError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl GetLicenseConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLicenseConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetLicenseConfigurationError::AccessDenied(
err.msg,
))
}
"AuthorizationException" => {
return RusotoError::Service(GetLicenseConfigurationError::Authorization(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(
GetLicenseConfigurationError::InvalidParameterValue(err.msg),
)
}
"RateLimitExceededException" => {
return RusotoError::Service(GetLicenseConfigurationError::RateLimitExceeded(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(GetLicenseConfigurationError::ServerInternal(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLicenseConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLicenseConfigurationError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetLicenseConfigurationError::Authorization(ref cause) => write!(f, "{}", cause),
GetLicenseConfigurationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetLicenseConfigurationError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetLicenseConfigurationError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLicenseConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetServiceSettingsError {
AccessDenied(String),
Authorization(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl GetServiceSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetServiceSettingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetServiceSettingsError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(GetServiceSettingsError::Authorization(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(GetServiceSettingsError::RateLimitExceeded(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(GetServiceSettingsError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetServiceSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetServiceSettingsError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetServiceSettingsError::Authorization(ref cause) => write!(f, "{}", cause),
GetServiceSettingsError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetServiceSettingsError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetServiceSettingsError {}
#[derive(Debug, PartialEq)]
pub enum ListAssociationsForLicenseConfigurationError {
AccessDenied(String),
Authorization(String),
FilterLimitExceeded(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl ListAssociationsForLicenseConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListAssociationsForLicenseConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
ListAssociationsForLicenseConfigurationError::AccessDenied(err.msg),
)
}
"AuthorizationException" => {
return RusotoError::Service(
ListAssociationsForLicenseConfigurationError::Authorization(err.msg),
)
}
"FilterLimitExceededException" => {
return RusotoError::Service(
ListAssociationsForLicenseConfigurationError::FilterLimitExceeded(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
ListAssociationsForLicenseConfigurationError::InvalidParameterValue(
err.msg,
),
)
}
"RateLimitExceededException" => {
return RusotoError::Service(
ListAssociationsForLicenseConfigurationError::RateLimitExceeded(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(
ListAssociationsForLicenseConfigurationError::ServerInternal(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAssociationsForLicenseConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAssociationsForLicenseConfigurationError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ListAssociationsForLicenseConfigurationError::Authorization(ref cause) => {
write!(f, "{}", cause)
}
ListAssociationsForLicenseConfigurationError::FilterLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ListAssociationsForLicenseConfigurationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListAssociationsForLicenseConfigurationError::RateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ListAssociationsForLicenseConfigurationError::ServerInternal(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListAssociationsForLicenseConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum ListFailuresForLicenseConfigurationOperationsError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl ListFailuresForLicenseConfigurationOperationsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListFailuresForLicenseConfigurationOperationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
ListFailuresForLicenseConfigurationOperationsError::AccessDenied(err.msg),
)
}
"AuthorizationException" => {
return RusotoError::Service(
ListFailuresForLicenseConfigurationOperationsError::Authorization(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
ListFailuresForLicenseConfigurationOperationsError::InvalidParameterValue(
err.msg,
),
)
}
"RateLimitExceededException" => {
return RusotoError::Service(
ListFailuresForLicenseConfigurationOperationsError::RateLimitExceeded(
err.msg,
),
)
}
"ServerInternalException" => {
return RusotoError::Service(
ListFailuresForLicenseConfigurationOperationsError::ServerInternal(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFailuresForLicenseConfigurationOperationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFailuresForLicenseConfigurationOperationsError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ListFailuresForLicenseConfigurationOperationsError::Authorization(ref cause) => {
write!(f, "{}", cause)
}
ListFailuresForLicenseConfigurationOperationsError::InvalidParameterValue(
ref cause,
) => write!(f, "{}", cause),
ListFailuresForLicenseConfigurationOperationsError::RateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ListFailuresForLicenseConfigurationOperationsError::ServerInternal(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListFailuresForLicenseConfigurationOperationsError {}
#[derive(Debug, PartialEq)]
pub enum ListLicenseConfigurationsError {
AccessDenied(String),
Authorization(String),
FilterLimitExceeded(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl ListLicenseConfigurationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLicenseConfigurationsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListLicenseConfigurationsError::AccessDenied(
err.msg,
))
}
"AuthorizationException" => {
return RusotoError::Service(ListLicenseConfigurationsError::Authorization(
err.msg,
))
}
"FilterLimitExceededException" => {
return RusotoError::Service(
ListLicenseConfigurationsError::FilterLimitExceeded(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
ListLicenseConfigurationsError::InvalidParameterValue(err.msg),
)
}
"RateLimitExceededException" => {
return RusotoError::Service(ListLicenseConfigurationsError::RateLimitExceeded(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(ListLicenseConfigurationsError::ServerInternal(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLicenseConfigurationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLicenseConfigurationsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListLicenseConfigurationsError::Authorization(ref cause) => write!(f, "{}", cause),
ListLicenseConfigurationsError::FilterLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ListLicenseConfigurationsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListLicenseConfigurationsError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListLicenseConfigurationsError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLicenseConfigurationsError {}
#[derive(Debug, PartialEq)]
pub enum ListLicenseSpecificationsForResourceError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl ListLicenseSpecificationsForResourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListLicenseSpecificationsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
ListLicenseSpecificationsForResourceError::AccessDenied(err.msg),
)
}
"AuthorizationException" => {
return RusotoError::Service(
ListLicenseSpecificationsForResourceError::Authorization(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
ListLicenseSpecificationsForResourceError::InvalidParameterValue(err.msg),
)
}
"RateLimitExceededException" => {
return RusotoError::Service(
ListLicenseSpecificationsForResourceError::RateLimitExceeded(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(
ListLicenseSpecificationsForResourceError::ServerInternal(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLicenseSpecificationsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLicenseSpecificationsForResourceError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ListLicenseSpecificationsForResourceError::Authorization(ref cause) => {
write!(f, "{}", cause)
}
ListLicenseSpecificationsForResourceError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListLicenseSpecificationsForResourceError::RateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ListLicenseSpecificationsForResourceError::ServerInternal(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListLicenseSpecificationsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListResourceInventoryError {
AccessDenied(String),
Authorization(String),
FailedDependency(String),
FilterLimitExceeded(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl ListResourceInventoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListResourceInventoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListResourceInventoryError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(ListResourceInventoryError::Authorization(err.msg))
}
"FailedDependencyException" => {
return RusotoError::Service(ListResourceInventoryError::FailedDependency(
err.msg,
))
}
"FilterLimitExceededException" => {
return RusotoError::Service(ListResourceInventoryError::FilterLimitExceeded(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(ListResourceInventoryError::InvalidParameterValue(
err.msg,
))
}
"RateLimitExceededException" => {
return RusotoError::Service(ListResourceInventoryError::RateLimitExceeded(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(ListResourceInventoryError::ServerInternal(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResourceInventoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResourceInventoryError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListResourceInventoryError::Authorization(ref cause) => write!(f, "{}", cause),
ListResourceInventoryError::FailedDependency(ref cause) => write!(f, "{}", cause),
ListResourceInventoryError::FilterLimitExceeded(ref cause) => write!(f, "{}", cause),
ListResourceInventoryError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListResourceInventoryError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListResourceInventoryError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResourceInventoryError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListTagsForResourceError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(ListTagsForResourceError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidParameterValue(
err.msg,
))
}
"RateLimitExceededException" => {
return RusotoError::Service(ListTagsForResourceError::RateLimitExceeded(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(ListTagsForResourceError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::Authorization(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListUsageForLicenseConfigurationError {
AccessDenied(String),
Authorization(String),
FilterLimitExceeded(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl ListUsageForLicenseConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListUsageForLicenseConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
ListUsageForLicenseConfigurationError::AccessDenied(err.msg),
)
}
"AuthorizationException" => {
return RusotoError::Service(
ListUsageForLicenseConfigurationError::Authorization(err.msg),
)
}
"FilterLimitExceededException" => {
return RusotoError::Service(
ListUsageForLicenseConfigurationError::FilterLimitExceeded(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
ListUsageForLicenseConfigurationError::InvalidParameterValue(err.msg),
)
}
"RateLimitExceededException" => {
return RusotoError::Service(
ListUsageForLicenseConfigurationError::RateLimitExceeded(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(
ListUsageForLicenseConfigurationError::ServerInternal(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListUsageForLicenseConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListUsageForLicenseConfigurationError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ListUsageForLicenseConfigurationError::Authorization(ref cause) => {
write!(f, "{}", cause)
}
ListUsageForLicenseConfigurationError::FilterLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ListUsageForLicenseConfigurationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListUsageForLicenseConfigurationError::RateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
ListUsageForLicenseConfigurationError::ServerInternal(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListUsageForLicenseConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(TagResourceError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(TagResourceError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(TagResourceError::InvalidParameterValue(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(TagResourceError::RateLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(TagResourceError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
TagResourceError::Authorization(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
TagResourceError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
TagResourceError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UntagResourceError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(UntagResourceError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(UntagResourceError::InvalidParameterValue(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(UntagResourceError::RateLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(UntagResourceError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
UntagResourceError::Authorization(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
UntagResourceError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
UntagResourceError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateLicenseConfigurationError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl UpdateLicenseConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateLicenseConfigurationError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateLicenseConfigurationError::AccessDenied(
err.msg,
))
}
"AuthorizationException" => {
return RusotoError::Service(UpdateLicenseConfigurationError::Authorization(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(
UpdateLicenseConfigurationError::InvalidParameterValue(err.msg),
)
}
"RateLimitExceededException" => {
return RusotoError::Service(
UpdateLicenseConfigurationError::RateLimitExceeded(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(UpdateLicenseConfigurationError::ServerInternal(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateLicenseConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateLicenseConfigurationError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateLicenseConfigurationError::Authorization(ref cause) => write!(f, "{}", cause),
UpdateLicenseConfigurationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
UpdateLicenseConfigurationError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateLicenseConfigurationError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateLicenseConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateLicenseSpecificationsForResourceError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
InvalidResourceState(String),
LicenseUsage(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl UpdateLicenseSpecificationsForResourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateLicenseSpecificationsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(
UpdateLicenseSpecificationsForResourceError::AccessDenied(err.msg),
)
}
"AuthorizationException" => {
return RusotoError::Service(
UpdateLicenseSpecificationsForResourceError::Authorization(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
UpdateLicenseSpecificationsForResourceError::InvalidParameterValue(err.msg),
)
}
"InvalidResourceStateException" => {
return RusotoError::Service(
UpdateLicenseSpecificationsForResourceError::InvalidResourceState(err.msg),
)
}
"LicenseUsageException" => {
return RusotoError::Service(
UpdateLicenseSpecificationsForResourceError::LicenseUsage(err.msg),
)
}
"RateLimitExceededException" => {
return RusotoError::Service(
UpdateLicenseSpecificationsForResourceError::RateLimitExceeded(err.msg),
)
}
"ServerInternalException" => {
return RusotoError::Service(
UpdateLicenseSpecificationsForResourceError::ServerInternal(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateLicenseSpecificationsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateLicenseSpecificationsForResourceError::AccessDenied(ref cause) => {
write!(f, "{}", cause)
}
UpdateLicenseSpecificationsForResourceError::Authorization(ref cause) => {
write!(f, "{}", cause)
}
UpdateLicenseSpecificationsForResourceError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
UpdateLicenseSpecificationsForResourceError::InvalidResourceState(ref cause) => {
write!(f, "{}", cause)
}
UpdateLicenseSpecificationsForResourceError::LicenseUsage(ref cause) => {
write!(f, "{}", cause)
}
UpdateLicenseSpecificationsForResourceError::RateLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
UpdateLicenseSpecificationsForResourceError::ServerInternal(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateLicenseSpecificationsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateServiceSettingsError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl UpdateServiceSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateServiceSettingsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateServiceSettingsError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(UpdateServiceSettingsError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(UpdateServiceSettingsError::InvalidParameterValue(
err.msg,
))
}
"RateLimitExceededException" => {
return RusotoError::Service(UpdateServiceSettingsError::RateLimitExceeded(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(UpdateServiceSettingsError::ServerInternal(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateServiceSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateServiceSettingsError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateServiceSettingsError::Authorization(ref cause) => write!(f, "{}", cause),
UpdateServiceSettingsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
UpdateServiceSettingsError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateServiceSettingsError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateServiceSettingsError {}
#[async_trait]
pub trait LicenseManager {
async fn create_license_configuration(
&self,
input: CreateLicenseConfigurationRequest,
) -> Result<CreateLicenseConfigurationResponse, RusotoError<CreateLicenseConfigurationError>>;
async fn delete_license_configuration(
&self,
input: DeleteLicenseConfigurationRequest,
) -> Result<DeleteLicenseConfigurationResponse, RusotoError<DeleteLicenseConfigurationError>>;
async fn get_license_configuration(
&self,
input: GetLicenseConfigurationRequest,
) -> Result<GetLicenseConfigurationResponse, RusotoError<GetLicenseConfigurationError>>;
async fn get_service_settings(
&self,
) -> Result<GetServiceSettingsResponse, RusotoError<GetServiceSettingsError>>;
async fn list_associations_for_license_configuration(
&self,
input: ListAssociationsForLicenseConfigurationRequest,
) -> Result<
ListAssociationsForLicenseConfigurationResponse,
RusotoError<ListAssociationsForLicenseConfigurationError>,
>;
async fn list_failures_for_license_configuration_operations(
&self,
input: ListFailuresForLicenseConfigurationOperationsRequest,
) -> Result<
ListFailuresForLicenseConfigurationOperationsResponse,
RusotoError<ListFailuresForLicenseConfigurationOperationsError>,
>;
async fn list_license_configurations(
&self,
input: ListLicenseConfigurationsRequest,
) -> Result<ListLicenseConfigurationsResponse, RusotoError<ListLicenseConfigurationsError>>;
async fn list_license_specifications_for_resource(
&self,
input: ListLicenseSpecificationsForResourceRequest,
) -> Result<
ListLicenseSpecificationsForResourceResponse,
RusotoError<ListLicenseSpecificationsForResourceError>,
>;
async fn list_resource_inventory(
&self,
input: ListResourceInventoryRequest,
) -> Result<ListResourceInventoryResponse, RusotoError<ListResourceInventoryError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_usage_for_license_configuration(
&self,
input: ListUsageForLicenseConfigurationRequest,
) -> Result<
ListUsageForLicenseConfigurationResponse,
RusotoError<ListUsageForLicenseConfigurationError>,
>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_license_configuration(
&self,
input: UpdateLicenseConfigurationRequest,
) -> Result<UpdateLicenseConfigurationResponse, RusotoError<UpdateLicenseConfigurationError>>;
async fn update_license_specifications_for_resource(
&self,
input: UpdateLicenseSpecificationsForResourceRequest,
) -> Result<
UpdateLicenseSpecificationsForResourceResponse,
RusotoError<UpdateLicenseSpecificationsForResourceError>,
>;
async fn update_service_settings(
&self,
input: UpdateServiceSettingsRequest,
) -> Result<UpdateServiceSettingsResponse, RusotoError<UpdateServiceSettingsError>>;
}
#[derive(Clone)]
pub struct LicenseManagerClient {
client: Client,
region: region::Region,
}
impl LicenseManagerClient {
pub fn new(region: region::Region) -> LicenseManagerClient {
LicenseManagerClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> LicenseManagerClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
LicenseManagerClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> LicenseManagerClient {
LicenseManagerClient { client, region }
}
}
#[async_trait]
impl LicenseManager for LicenseManagerClient {
async fn create_license_configuration(
&self,
input: CreateLicenseConfigurationRequest,
) -> Result<CreateLicenseConfigurationResponse, RusotoError<CreateLicenseConfigurationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSLicenseManager.CreateLicenseConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLicenseConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateLicenseConfigurationResponse, _>()
}
async fn delete_license_configuration(
&self,
input: DeleteLicenseConfigurationRequest,
) -> Result<DeleteLicenseConfigurationResponse, RusotoError<DeleteLicenseConfigurationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSLicenseManager.DeleteLicenseConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteLicenseConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteLicenseConfigurationResponse, _>()
}
async fn get_license_configuration(
&self,
input: GetLicenseConfigurationRequest,
) -> Result<GetLicenseConfigurationResponse, RusotoError<GetLicenseConfigurationError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.GetLicenseConfiguration");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetLicenseConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetLicenseConfigurationResponse, _>()
}
async fn get_service_settings(
&self,
) -> Result<GetServiceSettingsResponse, RusotoError<GetServiceSettingsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.GetServiceSettings");
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, GetServiceSettingsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetServiceSettingsResponse, _>()
}
async fn list_associations_for_license_configuration(
&self,
input: ListAssociationsForLicenseConfigurationRequest,
) -> Result<
ListAssociationsForLicenseConfigurationResponse,
RusotoError<ListAssociationsForLicenseConfigurationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSLicenseManager.ListAssociationsForLicenseConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListAssociationsForLicenseConfigurationError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListAssociationsForLicenseConfigurationResponse, _>()
}
async fn list_failures_for_license_configuration_operations(
&self,
input: ListFailuresForLicenseConfigurationOperationsRequest,
) -> Result<
ListFailuresForLicenseConfigurationOperationsResponse,
RusotoError<ListFailuresForLicenseConfigurationOperationsError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSLicenseManager.ListFailuresForLicenseConfigurationOperations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListFailuresForLicenseConfigurationOperationsError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListFailuresForLicenseConfigurationOperationsResponse, _>()
}
async fn list_license_configurations(
&self,
input: ListLicenseConfigurationsRequest,
) -> Result<ListLicenseConfigurationsResponse, RusotoError<ListLicenseConfigurationsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSLicenseManager.ListLicenseConfigurations",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListLicenseConfigurationsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListLicenseConfigurationsResponse, _>()
}
async fn list_license_specifications_for_resource(
&self,
input: ListLicenseSpecificationsForResourceRequest,
) -> Result<
ListLicenseSpecificationsForResourceResponse,
RusotoError<ListLicenseSpecificationsForResourceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSLicenseManager.ListLicenseSpecificationsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListLicenseSpecificationsForResourceError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListLicenseSpecificationsForResourceResponse, _>()
}
async fn list_resource_inventory(
&self,
input: ListResourceInventoryRequest,
) -> Result<ListResourceInventoryResponse, RusotoError<ListResourceInventoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.ListResourceInventory");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListResourceInventoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListResourceInventoryResponse, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.ListTagsForResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceResponse, _>()
}
async fn list_usage_for_license_configuration(
&self,
input: ListUsageForLicenseConfigurationRequest,
) -> Result<
ListUsageForLicenseConfigurationResponse,
RusotoError<ListUsageForLicenseConfigurationError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSLicenseManager.ListUsageForLicenseConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListUsageForLicenseConfigurationError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListUsageForLicenseConfigurationResponse, _>()
}
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<TagResourceResponse, _>()
}
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UntagResourceResponse, _>()
}
async fn update_license_configuration(
&self,
input: UpdateLicenseConfigurationRequest,
) -> Result<UpdateLicenseConfigurationResponse, RusotoError<UpdateLicenseConfigurationError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSLicenseManager.UpdateLicenseConfiguration",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateLicenseConfigurationError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateLicenseConfigurationResponse, _>()
}
async fn update_license_specifications_for_resource(
&self,
input: UpdateLicenseSpecificationsForResourceRequest,
) -> Result<
UpdateLicenseSpecificationsForResourceResponse,
RusotoError<UpdateLicenseSpecificationsForResourceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWSLicenseManager.UpdateLicenseSpecificationsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
UpdateLicenseSpecificationsForResourceError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateLicenseSpecificationsForResourceResponse, _>()
}
async fn update_service_settings(
&self,
input: UpdateServiceSettingsRequest,
) -> Result<UpdateServiceSettingsResponse, RusotoError<UpdateServiceSettingsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.UpdateServiceSettings");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateServiceSettingsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateServiceSettingsResponse, _>()
}
}