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, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AcceptGrantRequest {
#[serde(rename = "GrantArn")]
pub grant_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AcceptGrantResponse {
#[serde(rename = "GrantArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grant_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[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, Serialize)]
pub struct BorrowConfiguration {
#[serde(rename = "AllowEarlyCheckIn")]
pub allow_early_check_in: bool,
#[serde(rename = "MaxTimeToLiveInMinutes")]
pub max_time_to_live_in_minutes: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CheckInLicenseRequest {
#[serde(rename = "Beneficiary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub beneficiary: Option<String>,
#[serde(rename = "LicenseConsumptionToken")]
pub license_consumption_token: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CheckInLicenseResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CheckoutBorrowLicenseRequest {
#[serde(rename = "CheckoutMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkout_metadata: Option<Vec<Metadata>>,
#[serde(rename = "ClientToken")]
pub client_token: String,
#[serde(rename = "DigitalSignatureMethod")]
pub digital_signature_method: String,
#[serde(rename = "Entitlements")]
pub entitlements: Vec<EntitlementData>,
#[serde(rename = "LicenseArn")]
pub license_arn: String,
#[serde(rename = "NodeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub node_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CheckoutBorrowLicenseResponse {
#[serde(rename = "CheckoutMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkout_metadata: Option<Vec<Metadata>>,
#[serde(rename = "EntitlementsAllowed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlements_allowed: Option<Vec<EntitlementData>>,
#[serde(rename = "Expiration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration: Option<String>,
#[serde(rename = "IssuedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issued_at: Option<String>,
#[serde(rename = "LicenseArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_arn: Option<String>,
#[serde(rename = "LicenseConsumptionToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_consumption_token: Option<String>,
#[serde(rename = "NodeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub node_id: Option<String>,
#[serde(rename = "SignedToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signed_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CheckoutLicenseRequest {
#[serde(rename = "Beneficiary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub beneficiary: Option<String>,
#[serde(rename = "CheckoutType")]
pub checkout_type: String,
#[serde(rename = "ClientToken")]
pub client_token: String,
#[serde(rename = "Entitlements")]
pub entitlements: Vec<EntitlementData>,
#[serde(rename = "KeyFingerprint")]
pub key_fingerprint: String,
#[serde(rename = "NodeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub node_id: Option<String>,
#[serde(rename = "ProductSKU")]
pub product_sku: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CheckoutLicenseResponse {
#[serde(rename = "CheckoutType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub checkout_type: Option<String>,
#[serde(rename = "EntitlementsAllowed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlements_allowed: Option<Vec<EntitlementData>>,
#[serde(rename = "Expiration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration: Option<String>,
#[serde(rename = "IssuedAt")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issued_at: Option<String>,
#[serde(rename = "LicenseConsumptionToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_consumption_token: Option<String>,
#[serde(rename = "NodeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub node_id: Option<String>,
#[serde(rename = "SignedToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signed_token: Option<String>,
}
#[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, Deserialize, PartialEq, Serialize)]
pub struct ConsumptionConfiguration {
#[serde(rename = "BorrowConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub borrow_configuration: Option<BorrowConfiguration>,
#[serde(rename = "ProvisionalConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisional_configuration: Option<ProvisionalConfiguration>,
#[serde(rename = "RenewType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub renew_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateGrantRequest {
#[serde(rename = "AllowedOperations")]
pub allowed_operations: Vec<String>,
#[serde(rename = "ClientToken")]
pub client_token: String,
#[serde(rename = "GrantName")]
pub grant_name: String,
#[serde(rename = "HomeRegion")]
pub home_region: String,
#[serde(rename = "LicenseArn")]
pub license_arn: String,
#[serde(rename = "Principals")]
pub principals: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateGrantResponse {
#[serde(rename = "GrantArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grant_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateGrantVersionRequest {
#[serde(rename = "AllowedOperations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_operations: Option<Vec<String>>,
#[serde(rename = "ClientToken")]
pub client_token: String,
#[serde(rename = "GrantArn")]
pub grant_arn: String,
#[serde(rename = "GrantName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grant_name: Option<String>,
#[serde(rename = "SourceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_version: Option<String>,
#[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 CreateGrantVersionResponse {
#[serde(rename = "GrantArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grant_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: 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 = "DisassociateWhenNotFound")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disassociate_when_not_found: Option<bool>,
#[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 CreateLicenseRequest {
#[serde(rename = "Beneficiary")]
pub beneficiary: String,
#[serde(rename = "ClientToken")]
pub client_token: String,
#[serde(rename = "ConsumptionConfiguration")]
pub consumption_configuration: ConsumptionConfiguration,
#[serde(rename = "Entitlements")]
pub entitlements: Vec<Entitlement>,
#[serde(rename = "HomeRegion")]
pub home_region: String,
#[serde(rename = "Issuer")]
pub issuer: Issuer,
#[serde(rename = "LicenseMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_metadata: Option<Vec<Metadata>>,
#[serde(rename = "LicenseName")]
pub license_name: String,
#[serde(rename = "ProductName")]
pub product_name: String,
#[serde(rename = "ProductSKU")]
pub product_sku: String,
#[serde(rename = "Validity")]
pub validity: DatetimeRange,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLicenseResponse {
#[serde(rename = "LicenseArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateLicenseVersionRequest {
#[serde(rename = "ClientToken")]
pub client_token: String,
#[serde(rename = "ConsumptionConfiguration")]
pub consumption_configuration: ConsumptionConfiguration,
#[serde(rename = "Entitlements")]
pub entitlements: Vec<Entitlement>,
#[serde(rename = "HomeRegion")]
pub home_region: String,
#[serde(rename = "Issuer")]
pub issuer: Issuer,
#[serde(rename = "LicenseArn")]
pub license_arn: String,
#[serde(rename = "LicenseMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_metadata: Option<Vec<Metadata>>,
#[serde(rename = "LicenseName")]
pub license_name: String,
#[serde(rename = "ProductName")]
pub product_name: String,
#[serde(rename = "SourceVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_version: Option<String>,
#[serde(rename = "Status")]
pub status: String,
#[serde(rename = "Validity")]
pub validity: DatetimeRange,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateLicenseVersionResponse {
#[serde(rename = "LicenseArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTokenRequest {
#[serde(rename = "ClientToken")]
pub client_token: String,
#[serde(rename = "ExpirationInDays")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_in_days: Option<i64>,
#[serde(rename = "LicenseArn")]
pub license_arn: String,
#[serde(rename = "RoleArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arns: Option<Vec<String>>,
#[serde(rename = "TokenProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_properties: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTokenResponse {
#[serde(rename = "Token")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token: Option<String>,
#[serde(rename = "TokenId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_id: Option<String>,
#[serde(rename = "TokenType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DatetimeRange {
#[serde(rename = "Begin")]
pub begin: String,
#[serde(rename = "End")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteGrantRequest {
#[serde(rename = "GrantArn")]
pub grant_arn: String,
#[serde(rename = "Version")]
pub version: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteGrantResponse {
#[serde(rename = "GrantArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grant_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: 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 DeleteLicenseRequest {
#[serde(rename = "LicenseArn")]
pub license_arn: String,
#[serde(rename = "SourceVersion")]
pub source_version: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteLicenseResponse {
#[serde(rename = "DeletionDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deletion_date: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTokenRequest {
#[serde(rename = "TokenId")]
pub token_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTokenResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Entitlement {
#[serde(rename = "AllowCheckIn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_check_in: Option<bool>,
#[serde(rename = "MaxCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_count: Option<i64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Overage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub overage: Option<bool>,
#[serde(rename = "Unit")]
pub unit: String,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct EntitlementData {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Unit")]
pub unit: 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 EntitlementUsage {
#[serde(rename = "ConsumedValue")]
pub consumed_value: String,
#[serde(rename = "MaxCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_count: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Unit")]
pub unit: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ExtendLicenseConsumptionRequest {
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "LicenseConsumptionToken")]
pub license_consumption_token: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExtendLicenseConsumptionResponse {
#[serde(rename = "Expiration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration: Option<String>,
#[serde(rename = "LicenseConsumptionToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_consumption_token: Option<String>,
}
#[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 GetAccessTokenRequest {
#[serde(rename = "Token")]
pub token: String,
#[serde(rename = "TokenProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_properties: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAccessTokenResponse {
#[serde(rename = "AccessToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetGrantRequest {
#[serde(rename = "GrantArn")]
pub grant_arn: String,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetGrantResponse {
#[serde(rename = "Grant")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grant: Option<Grant>,
}
#[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 = "DisassociateWhenNotFound")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disassociate_when_not_found: Option<bool>,
#[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 GetLicenseRequest {
#[serde(rename = "LicenseArn")]
pub license_arn: String,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLicenseResponse {
#[serde(rename = "License")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license: Option<License>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLicenseUsageRequest {
#[serde(rename = "LicenseArn")]
pub license_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLicenseUsageResponse {
#[serde(rename = "LicenseUsage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_usage: Option<LicenseUsage>,
}
#[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, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Grant {
#[serde(rename = "GrantArn")]
pub grant_arn: String,
#[serde(rename = "GrantName")]
pub grant_name: String,
#[serde(rename = "GrantStatus")]
pub grant_status: String,
#[serde(rename = "GrantedOperations")]
pub granted_operations: Vec<String>,
#[serde(rename = "GranteePrincipalArn")]
pub grantee_principal_arn: String,
#[serde(rename = "HomeRegion")]
pub home_region: String,
#[serde(rename = "LicenseArn")]
pub license_arn: String,
#[serde(rename = "ParentArn")]
pub parent_arn: String,
#[serde(rename = "StatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_reason: Option<String>,
#[serde(rename = "Version")]
pub version: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GrantedLicense {
#[serde(rename = "Beneficiary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub beneficiary: Option<String>,
#[serde(rename = "ConsumptionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consumption_configuration: Option<ConsumptionConfiguration>,
#[serde(rename = "CreateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<String>,
#[serde(rename = "Entitlements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlements: Option<Vec<Entitlement>>,
#[serde(rename = "HomeRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub home_region: Option<String>,
#[serde(rename = "Issuer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<IssuerDetails>,
#[serde(rename = "LicenseArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_arn: Option<String>,
#[serde(rename = "LicenseMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_metadata: Option<Vec<Metadata>>,
#[serde(rename = "LicenseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_name: Option<String>,
#[serde(rename = "ProductName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_name: Option<String>,
#[serde(rename = "ProductSKU")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_sku: Option<String>,
#[serde(rename = "ReceivedMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub received_metadata: Option<ReceivedMetadata>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Validity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validity: Option<DatetimeRange>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: 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, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Issuer {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SignKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sign_key: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IssuerDetails {
#[serde(rename = "KeyFingerprint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key_fingerprint: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SignKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sign_key: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct License {
#[serde(rename = "Beneficiary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub beneficiary: Option<String>,
#[serde(rename = "ConsumptionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consumption_configuration: Option<ConsumptionConfiguration>,
#[serde(rename = "CreateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_time: Option<String>,
#[serde(rename = "Entitlements")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlements: Option<Vec<Entitlement>>,
#[serde(rename = "HomeRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub home_region: Option<String>,
#[serde(rename = "Issuer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<IssuerDetails>,
#[serde(rename = "LicenseArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_arn: Option<String>,
#[serde(rename = "LicenseMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_metadata: Option<Vec<Metadata>>,
#[serde(rename = "LicenseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_name: Option<String>,
#[serde(rename = "ProductName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_name: Option<String>,
#[serde(rename = "ProductSKU")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_sku: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Validity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub validity: Option<DatetimeRange>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: 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 = "DisassociateWhenNotFound")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disassociate_when_not_found: Option<bool>,
#[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 = "AmiAssociationScope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ami_association_scope: Option<String>,
#[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 = "AmiAssociationScope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ami_association_scope: Option<String>,
#[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 LicenseUsage {
#[serde(rename = "EntitlementUsages")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entitlement_usages: Option<Vec<EntitlementUsage>>,
}
#[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 ListDistributedGrantsRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "GrantArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grant_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 ListDistributedGrantsResponse {
#[serde(rename = "Grants")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grants: Option<Vec<Grant>>,
#[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 ListLicenseVersionsRequest {
#[serde(rename = "LicenseArn")]
pub license_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 ListLicenseVersionsResponse {
#[serde(rename = "Licenses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub licenses: Option<Vec<License>>,
#[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 ListLicensesRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "LicenseArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_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 ListLicensesResponse {
#[serde(rename = "Licenses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub licenses: Option<Vec<License>>,
#[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 ListReceivedGrantsRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "GrantArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grant_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 ListReceivedGrantsResponse {
#[serde(rename = "Grants")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grants: Option<Vec<Grant>>,
#[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 ListReceivedLicensesRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[serde(rename = "LicenseArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_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 ListReceivedLicensesResponse {
#[serde(rename = "Licenses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub licenses: Option<Vec<GrantedLicense>>,
#[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 ListTokensRequest {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<Vec<Filter>>,
#[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 = "TokenIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTokensResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "Tokens")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tokens: Option<Vec<TokenData>>,
}
#[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, 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, Serialize)]
pub struct ProvisionalConfiguration {
#[serde(rename = "MaxTimeToLiveInMinutes")]
pub max_time_to_live_in_minutes: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReceivedMetadata {
#[serde(rename = "AllowedOperations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_operations: Option<Vec<String>>,
#[serde(rename = "ReceivedStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub received_status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RejectGrantRequest {
#[serde(rename = "GrantArn")]
pub grant_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RejectGrantResponse {
#[serde(rename = "GrantArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub grant_arn: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<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, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TokenData {
#[serde(rename = "ExpirationTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expiration_time: Option<String>,
#[serde(rename = "LicenseArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_arn: Option<String>,
#[serde(rename = "RoleArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role_arns: Option<Vec<String>>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "TokenId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_id: Option<String>,
#[serde(rename = "TokenProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_properties: Option<Vec<String>>,
#[serde(rename = "TokenType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub token_type: Option<String>,
}
#[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 = "DisassociateWhenNotFound")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disassociate_when_not_found: Option<bool>,
#[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 AcceptGrantError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ResourceLimitExceeded(String),
ServerInternal(String),
}
impl AcceptGrantError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AcceptGrantError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AcceptGrantError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(AcceptGrantError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(AcceptGrantError::InvalidParameterValue(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(AcceptGrantError::RateLimitExceeded(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(AcceptGrantError::ResourceLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(AcceptGrantError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AcceptGrantError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AcceptGrantError::AccessDenied(ref cause) => write!(f, "{}", cause),
AcceptGrantError::Authorization(ref cause) => write!(f, "{}", cause),
AcceptGrantError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
AcceptGrantError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
AcceptGrantError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
AcceptGrantError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AcceptGrantError {}
#[derive(Debug, PartialEq)]
pub enum CheckInLicenseError {
AccessDenied(String),
Authorization(String),
Conflict(String),
RateLimitExceeded(String),
ResourceNotFound(String),
ServerInternal(String),
}
impl CheckInLicenseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CheckInLicenseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CheckInLicenseError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(CheckInLicenseError::Authorization(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CheckInLicenseError::Conflict(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(CheckInLicenseError::RateLimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CheckInLicenseError::ResourceNotFound(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(CheckInLicenseError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CheckInLicenseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CheckInLicenseError::AccessDenied(ref cause) => write!(f, "{}", cause),
CheckInLicenseError::Authorization(ref cause) => write!(f, "{}", cause),
CheckInLicenseError::Conflict(ref cause) => write!(f, "{}", cause),
CheckInLicenseError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
CheckInLicenseError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CheckInLicenseError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CheckInLicenseError {}
#[derive(Debug, PartialEq)]
pub enum CheckoutBorrowLicenseError {
AccessDenied(String),
Authorization(String),
EntitlementNotAllowed(String),
NoEntitlementsAllowed(String),
RateLimitExceeded(String),
Redirect(String),
ResourceNotFound(String),
ServerInternal(String),
UnsupportedDigitalSignatureMethod(String),
}
impl CheckoutBorrowLicenseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CheckoutBorrowLicenseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CheckoutBorrowLicenseError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(CheckoutBorrowLicenseError::Authorization(err.msg))
}
"EntitlementNotAllowedException" => {
return RusotoError::Service(CheckoutBorrowLicenseError::EntitlementNotAllowed(
err.msg,
))
}
"NoEntitlementsAllowedException" => {
return RusotoError::Service(CheckoutBorrowLicenseError::NoEntitlementsAllowed(
err.msg,
))
}
"RateLimitExceededException" => {
return RusotoError::Service(CheckoutBorrowLicenseError::RateLimitExceeded(
err.msg,
))
}
"RedirectException" => {
return RusotoError::Service(CheckoutBorrowLicenseError::Redirect(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CheckoutBorrowLicenseError::ResourceNotFound(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(CheckoutBorrowLicenseError::ServerInternal(
err.msg,
))
}
"UnsupportedDigitalSignatureMethodException" => {
return RusotoError::Service(
CheckoutBorrowLicenseError::UnsupportedDigitalSignatureMethod(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CheckoutBorrowLicenseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CheckoutBorrowLicenseError::AccessDenied(ref cause) => write!(f, "{}", cause),
CheckoutBorrowLicenseError::Authorization(ref cause) => write!(f, "{}", cause),
CheckoutBorrowLicenseError::EntitlementNotAllowed(ref cause) => write!(f, "{}", cause),
CheckoutBorrowLicenseError::NoEntitlementsAllowed(ref cause) => write!(f, "{}", cause),
CheckoutBorrowLicenseError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
CheckoutBorrowLicenseError::Redirect(ref cause) => write!(f, "{}", cause),
CheckoutBorrowLicenseError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CheckoutBorrowLicenseError::ServerInternal(ref cause) => write!(f, "{}", cause),
CheckoutBorrowLicenseError::UnsupportedDigitalSignatureMethod(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CheckoutBorrowLicenseError {}
#[derive(Debug, PartialEq)]
pub enum CheckoutLicenseError {
AccessDenied(String),
Authorization(String),
NoEntitlementsAllowed(String),
RateLimitExceeded(String),
Redirect(String),
ResourceNotFound(String),
ServerInternal(String),
UnsupportedDigitalSignatureMethod(String),
}
impl CheckoutLicenseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CheckoutLicenseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CheckoutLicenseError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(CheckoutLicenseError::Authorization(err.msg))
}
"NoEntitlementsAllowedException" => {
return RusotoError::Service(CheckoutLicenseError::NoEntitlementsAllowed(
err.msg,
))
}
"RateLimitExceededException" => {
return RusotoError::Service(CheckoutLicenseError::RateLimitExceeded(err.msg))
}
"RedirectException" => {
return RusotoError::Service(CheckoutLicenseError::Redirect(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CheckoutLicenseError::ResourceNotFound(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(CheckoutLicenseError::ServerInternal(err.msg))
}
"UnsupportedDigitalSignatureMethodException" => {
return RusotoError::Service(
CheckoutLicenseError::UnsupportedDigitalSignatureMethod(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CheckoutLicenseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CheckoutLicenseError::AccessDenied(ref cause) => write!(f, "{}", cause),
CheckoutLicenseError::Authorization(ref cause) => write!(f, "{}", cause),
CheckoutLicenseError::NoEntitlementsAllowed(ref cause) => write!(f, "{}", cause),
CheckoutLicenseError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
CheckoutLicenseError::Redirect(ref cause) => write!(f, "{}", cause),
CheckoutLicenseError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CheckoutLicenseError::ServerInternal(ref cause) => write!(f, "{}", cause),
CheckoutLicenseError::UnsupportedDigitalSignatureMethod(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CheckoutLicenseError {}
#[derive(Debug, PartialEq)]
pub enum CreateGrantError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ResourceLimitExceeded(String),
ServerInternal(String),
}
impl CreateGrantError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateGrantError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateGrantError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(CreateGrantError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(CreateGrantError::InvalidParameterValue(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(CreateGrantError::RateLimitExceeded(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(CreateGrantError::ResourceLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(CreateGrantError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateGrantError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateGrantError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateGrantError::Authorization(ref cause) => write!(f, "{}", cause),
CreateGrantError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateGrantError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateGrantError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateGrantError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateGrantError {}
#[derive(Debug, PartialEq)]
pub enum CreateGrantVersionError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ResourceLimitExceeded(String),
ServerInternal(String),
}
impl CreateGrantVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateGrantVersionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateGrantVersionError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(CreateGrantVersionError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(CreateGrantVersionError::InvalidParameterValue(
err.msg,
))
}
"RateLimitExceededException" => {
return RusotoError::Service(CreateGrantVersionError::RateLimitExceeded(
err.msg,
))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(CreateGrantVersionError::ResourceLimitExceeded(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(CreateGrantVersionError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateGrantVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateGrantVersionError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateGrantVersionError::Authorization(ref cause) => write!(f, "{}", cause),
CreateGrantVersionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateGrantVersionError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateGrantVersionError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateGrantVersionError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateGrantVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateLicenseError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
Redirect(String),
ServerInternal(String),
}
impl CreateLicenseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLicenseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateLicenseError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(CreateLicenseError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(CreateLicenseError::InvalidParameterValue(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(CreateLicenseError::RateLimitExceeded(err.msg))
}
"RedirectException" => {
return RusotoError::Service(CreateLicenseError::Redirect(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(CreateLicenseError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLicenseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLicenseError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateLicenseError::Authorization(ref cause) => write!(f, "{}", cause),
CreateLicenseError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateLicenseError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateLicenseError::Redirect(ref cause) => write!(f, "{}", cause),
CreateLicenseError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLicenseError {}
#[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 CreateLicenseVersionError {
AccessDenied(String),
Authorization(String),
Conflict(String),
RateLimitExceeded(String),
Redirect(String),
ResourceNotFound(String),
ServerInternal(String),
}
impl CreateLicenseVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateLicenseVersionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateLicenseVersionError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(CreateLicenseVersionError::Authorization(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateLicenseVersionError::Conflict(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(CreateLicenseVersionError::RateLimitExceeded(
err.msg,
))
}
"RedirectException" => {
return RusotoError::Service(CreateLicenseVersionError::Redirect(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateLicenseVersionError::ResourceNotFound(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(CreateLicenseVersionError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateLicenseVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateLicenseVersionError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateLicenseVersionError::Authorization(ref cause) => write!(f, "{}", cause),
CreateLicenseVersionError::Conflict(ref cause) => write!(f, "{}", cause),
CreateLicenseVersionError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateLicenseVersionError::Redirect(ref cause) => write!(f, "{}", cause),
CreateLicenseVersionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateLicenseVersionError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateLicenseVersionError {}
#[derive(Debug, PartialEq)]
pub enum CreateTokenError {
AccessDenied(String),
Authorization(String),
RateLimitExceeded(String),
Redirect(String),
ResourceLimitExceeded(String),
ResourceNotFound(String),
ServerInternal(String),
}
impl CreateTokenError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTokenError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateTokenError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(CreateTokenError::Authorization(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(CreateTokenError::RateLimitExceeded(err.msg))
}
"RedirectException" => {
return RusotoError::Service(CreateTokenError::Redirect(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(CreateTokenError::ResourceLimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateTokenError::ResourceNotFound(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(CreateTokenError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTokenError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTokenError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateTokenError::Authorization(ref cause) => write!(f, "{}", cause),
CreateTokenError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateTokenError::Redirect(ref cause) => write!(f, "{}", cause),
CreateTokenError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateTokenError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateTokenError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTokenError {}
#[derive(Debug, PartialEq)]
pub enum DeleteGrantError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ResourceLimitExceeded(String),
ServerInternal(String),
}
impl DeleteGrantError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteGrantError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteGrantError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(DeleteGrantError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(DeleteGrantError::InvalidParameterValue(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(DeleteGrantError::RateLimitExceeded(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(DeleteGrantError::ResourceLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(DeleteGrantError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteGrantError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteGrantError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteGrantError::Authorization(ref cause) => write!(f, "{}", cause),
DeleteGrantError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteGrantError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteGrantError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteGrantError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteGrantError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLicenseError {
AccessDenied(String),
Authorization(String),
Conflict(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
Redirect(String),
ServerInternal(String),
}
impl DeleteLicenseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLicenseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteLicenseError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(DeleteLicenseError::Authorization(err.msg))
}
"ConflictException" => {
return RusotoError::Service(DeleteLicenseError::Conflict(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(DeleteLicenseError::InvalidParameterValue(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(DeleteLicenseError::RateLimitExceeded(err.msg))
}
"RedirectException" => {
return RusotoError::Service(DeleteLicenseError::Redirect(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(DeleteLicenseError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLicenseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLicenseError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteLicenseError::Authorization(ref cause) => write!(f, "{}", cause),
DeleteLicenseError::Conflict(ref cause) => write!(f, "{}", cause),
DeleteLicenseError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteLicenseError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteLicenseError::Redirect(ref cause) => write!(f, "{}", cause),
DeleteLicenseError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLicenseError {}
#[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 DeleteTokenError {
AccessDenied(String),
Authorization(String),
RateLimitExceeded(String),
Redirect(String),
ResourceNotFound(String),
ServerInternal(String),
}
impl DeleteTokenError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTokenError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteTokenError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(DeleteTokenError::Authorization(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(DeleteTokenError::RateLimitExceeded(err.msg))
}
"RedirectException" => {
return RusotoError::Service(DeleteTokenError::Redirect(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteTokenError::ResourceNotFound(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(DeleteTokenError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTokenError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTokenError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteTokenError::Authorization(ref cause) => write!(f, "{}", cause),
DeleteTokenError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteTokenError::Redirect(ref cause) => write!(f, "{}", cause),
DeleteTokenError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteTokenError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTokenError {}
#[derive(Debug, PartialEq)]
pub enum ExtendLicenseConsumptionError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ResourceNotFound(String),
ServerInternal(String),
}
impl ExtendLicenseConsumptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ExtendLicenseConsumptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ExtendLicenseConsumptionError::AccessDenied(
err.msg,
))
}
"AuthorizationException" => {
return RusotoError::Service(ExtendLicenseConsumptionError::Authorization(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(
ExtendLicenseConsumptionError::InvalidParameterValue(err.msg),
)
}
"RateLimitExceededException" => {
return RusotoError::Service(ExtendLicenseConsumptionError::RateLimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ExtendLicenseConsumptionError::ResourceNotFound(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(ExtendLicenseConsumptionError::ServerInternal(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ExtendLicenseConsumptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ExtendLicenseConsumptionError::AccessDenied(ref cause) => write!(f, "{}", cause),
ExtendLicenseConsumptionError::Authorization(ref cause) => write!(f, "{}", cause),
ExtendLicenseConsumptionError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ExtendLicenseConsumptionError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
ExtendLicenseConsumptionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ExtendLicenseConsumptionError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ExtendLicenseConsumptionError {}
#[derive(Debug, PartialEq)]
pub enum GetAccessTokenError {
AccessDenied(String),
Authorization(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl GetAccessTokenError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAccessTokenError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetAccessTokenError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(GetAccessTokenError::Authorization(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(GetAccessTokenError::RateLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(GetAccessTokenError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAccessTokenError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAccessTokenError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetAccessTokenError::Authorization(ref cause) => write!(f, "{}", cause),
GetAccessTokenError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetAccessTokenError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAccessTokenError {}
#[derive(Debug, PartialEq)]
pub enum GetGrantError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ResourceLimitExceeded(String),
ServerInternal(String),
}
impl GetGrantError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetGrantError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetGrantError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(GetGrantError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(GetGrantError::InvalidParameterValue(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(GetGrantError::RateLimitExceeded(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(GetGrantError::ResourceLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(GetGrantError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetGrantError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetGrantError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetGrantError::Authorization(ref cause) => write!(f, "{}", cause),
GetGrantError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetGrantError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetGrantError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
GetGrantError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetGrantError {}
#[derive(Debug, PartialEq)]
pub enum GetLicenseError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl GetLicenseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLicenseError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetLicenseError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(GetLicenseError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(GetLicenseError::InvalidParameterValue(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(GetLicenseError::RateLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(GetLicenseError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLicenseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLicenseError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetLicenseError::Authorization(ref cause) => write!(f, "{}", cause),
GetLicenseError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetLicenseError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetLicenseError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLicenseError {}
#[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 GetLicenseUsageError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl GetLicenseUsageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLicenseUsageError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetLicenseUsageError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(GetLicenseUsageError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(GetLicenseUsageError::InvalidParameterValue(
err.msg,
))
}
"RateLimitExceededException" => {
return RusotoError::Service(GetLicenseUsageError::RateLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(GetLicenseUsageError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLicenseUsageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLicenseUsageError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetLicenseUsageError::Authorization(ref cause) => write!(f, "{}", cause),
GetLicenseUsageError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetLicenseUsageError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
GetLicenseUsageError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLicenseUsageError {}
#[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 ListDistributedGrantsError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ResourceLimitExceeded(String),
ServerInternal(String),
}
impl ListDistributedGrantsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDistributedGrantsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListDistributedGrantsError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(ListDistributedGrantsError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(ListDistributedGrantsError::InvalidParameterValue(
err.msg,
))
}
"RateLimitExceededException" => {
return RusotoError::Service(ListDistributedGrantsError::RateLimitExceeded(
err.msg,
))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(ListDistributedGrantsError::ResourceLimitExceeded(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(ListDistributedGrantsError::ServerInternal(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDistributedGrantsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDistributedGrantsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListDistributedGrantsError::Authorization(ref cause) => write!(f, "{}", cause),
ListDistributedGrantsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListDistributedGrantsError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListDistributedGrantsError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
ListDistributedGrantsError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDistributedGrantsError {}
#[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 ListLicenseVersionsError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl ListLicenseVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLicenseVersionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListLicenseVersionsError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(ListLicenseVersionsError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(ListLicenseVersionsError::InvalidParameterValue(
err.msg,
))
}
"RateLimitExceededException" => {
return RusotoError::Service(ListLicenseVersionsError::RateLimitExceeded(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(ListLicenseVersionsError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLicenseVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLicenseVersionsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListLicenseVersionsError::Authorization(ref cause) => write!(f, "{}", cause),
ListLicenseVersionsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListLicenseVersionsError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListLicenseVersionsError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLicenseVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListLicensesError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl ListLicensesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLicensesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListLicensesError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(ListLicensesError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(ListLicensesError::InvalidParameterValue(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(ListLicensesError::RateLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(ListLicensesError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLicensesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLicensesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListLicensesError::Authorization(ref cause) => write!(f, "{}", cause),
ListLicensesError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListLicensesError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListLicensesError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLicensesError {}
#[derive(Debug, PartialEq)]
pub enum ListReceivedGrantsError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ResourceLimitExceeded(String),
ServerInternal(String),
}
impl ListReceivedGrantsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListReceivedGrantsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListReceivedGrantsError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(ListReceivedGrantsError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(ListReceivedGrantsError::InvalidParameterValue(
err.msg,
))
}
"RateLimitExceededException" => {
return RusotoError::Service(ListReceivedGrantsError::RateLimitExceeded(
err.msg,
))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(ListReceivedGrantsError::ResourceLimitExceeded(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(ListReceivedGrantsError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListReceivedGrantsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListReceivedGrantsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListReceivedGrantsError::Authorization(ref cause) => write!(f, "{}", cause),
ListReceivedGrantsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListReceivedGrantsError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListReceivedGrantsError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
ListReceivedGrantsError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListReceivedGrantsError {}
#[derive(Debug, PartialEq)]
pub enum ListReceivedLicensesError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ResourceLimitExceeded(String),
ServerInternal(String),
}
impl ListReceivedLicensesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListReceivedLicensesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListReceivedLicensesError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(ListReceivedLicensesError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(ListReceivedLicensesError::InvalidParameterValue(
err.msg,
))
}
"RateLimitExceededException" => {
return RusotoError::Service(ListReceivedLicensesError::RateLimitExceeded(
err.msg,
))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(ListReceivedLicensesError::ResourceLimitExceeded(
err.msg,
))
}
"ServerInternalException" => {
return RusotoError::Service(ListReceivedLicensesError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListReceivedLicensesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListReceivedLicensesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListReceivedLicensesError::Authorization(ref cause) => write!(f, "{}", cause),
ListReceivedLicensesError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListReceivedLicensesError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListReceivedLicensesError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
ListReceivedLicensesError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListReceivedLicensesError {}
#[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 ListTokensError {
AccessDenied(String),
Authorization(String),
RateLimitExceeded(String),
ServerInternal(String),
}
impl ListTokensError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTokensError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListTokensError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(ListTokensError::Authorization(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(ListTokensError::RateLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(ListTokensError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTokensError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTokensError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListTokensError::Authorization(ref cause) => write!(f, "{}", cause),
ListTokensError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
ListTokensError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTokensError {}
#[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 RejectGrantError {
AccessDenied(String),
Authorization(String),
InvalidParameterValue(String),
RateLimitExceeded(String),
ResourceLimitExceeded(String),
ServerInternal(String),
}
impl RejectGrantError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RejectGrantError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(RejectGrantError::AccessDenied(err.msg))
}
"AuthorizationException" => {
return RusotoError::Service(RejectGrantError::Authorization(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(RejectGrantError::InvalidParameterValue(err.msg))
}
"RateLimitExceededException" => {
return RusotoError::Service(RejectGrantError::RateLimitExceeded(err.msg))
}
"ResourceLimitExceededException" => {
return RusotoError::Service(RejectGrantError::ResourceLimitExceeded(err.msg))
}
"ServerInternalException" => {
return RusotoError::Service(RejectGrantError::ServerInternal(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RejectGrantError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RejectGrantError::AccessDenied(ref cause) => write!(f, "{}", cause),
RejectGrantError::Authorization(ref cause) => write!(f, "{}", cause),
RejectGrantError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
RejectGrantError::RateLimitExceeded(ref cause) => write!(f, "{}", cause),
RejectGrantError::ResourceLimitExceeded(ref cause) => write!(f, "{}", cause),
RejectGrantError::ServerInternal(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RejectGrantError {}
#[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),
ResourceLimitExceeded(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),
)
}
"ResourceLimitExceededException" => {
return RusotoError::Service(
UpdateLicenseConfigurationError::ResourceLimitExceeded(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::ResourceLimitExceeded(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 accept_grant(
&self,
input: AcceptGrantRequest,
) -> Result<AcceptGrantResponse, RusotoError<AcceptGrantError>>;
async fn check_in_license(
&self,
input: CheckInLicenseRequest,
) -> Result<CheckInLicenseResponse, RusotoError<CheckInLicenseError>>;
async fn checkout_borrow_license(
&self,
input: CheckoutBorrowLicenseRequest,
) -> Result<CheckoutBorrowLicenseResponse, RusotoError<CheckoutBorrowLicenseError>>;
async fn checkout_license(
&self,
input: CheckoutLicenseRequest,
) -> Result<CheckoutLicenseResponse, RusotoError<CheckoutLicenseError>>;
async fn create_grant(
&self,
input: CreateGrantRequest,
) -> Result<CreateGrantResponse, RusotoError<CreateGrantError>>;
async fn create_grant_version(
&self,
input: CreateGrantVersionRequest,
) -> Result<CreateGrantVersionResponse, RusotoError<CreateGrantVersionError>>;
async fn create_license(
&self,
input: CreateLicenseRequest,
) -> Result<CreateLicenseResponse, RusotoError<CreateLicenseError>>;
async fn create_license_configuration(
&self,
input: CreateLicenseConfigurationRequest,
) -> Result<CreateLicenseConfigurationResponse, RusotoError<CreateLicenseConfigurationError>>;
async fn create_license_version(
&self,
input: CreateLicenseVersionRequest,
) -> Result<CreateLicenseVersionResponse, RusotoError<CreateLicenseVersionError>>;
async fn create_token(
&self,
input: CreateTokenRequest,
) -> Result<CreateTokenResponse, RusotoError<CreateTokenError>>;
async fn delete_grant(
&self,
input: DeleteGrantRequest,
) -> Result<DeleteGrantResponse, RusotoError<DeleteGrantError>>;
async fn delete_license(
&self,
input: DeleteLicenseRequest,
) -> Result<DeleteLicenseResponse, RusotoError<DeleteLicenseError>>;
async fn delete_license_configuration(
&self,
input: DeleteLicenseConfigurationRequest,
) -> Result<DeleteLicenseConfigurationResponse, RusotoError<DeleteLicenseConfigurationError>>;
async fn delete_token(
&self,
input: DeleteTokenRequest,
) -> Result<DeleteTokenResponse, RusotoError<DeleteTokenError>>;
async fn extend_license_consumption(
&self,
input: ExtendLicenseConsumptionRequest,
) -> Result<ExtendLicenseConsumptionResponse, RusotoError<ExtendLicenseConsumptionError>>;
async fn get_access_token(
&self,
input: GetAccessTokenRequest,
) -> Result<GetAccessTokenResponse, RusotoError<GetAccessTokenError>>;
async fn get_grant(
&self,
input: GetGrantRequest,
) -> Result<GetGrantResponse, RusotoError<GetGrantError>>;
async fn get_license(
&self,
input: GetLicenseRequest,
) -> Result<GetLicenseResponse, RusotoError<GetLicenseError>>;
async fn get_license_configuration(
&self,
input: GetLicenseConfigurationRequest,
) -> Result<GetLicenseConfigurationResponse, RusotoError<GetLicenseConfigurationError>>;
async fn get_license_usage(
&self,
input: GetLicenseUsageRequest,
) -> Result<GetLicenseUsageResponse, RusotoError<GetLicenseUsageError>>;
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_distributed_grants(
&self,
input: ListDistributedGrantsRequest,
) -> Result<ListDistributedGrantsResponse, RusotoError<ListDistributedGrantsError>>;
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_license_versions(
&self,
input: ListLicenseVersionsRequest,
) -> Result<ListLicenseVersionsResponse, RusotoError<ListLicenseVersionsError>>;
async fn list_licenses(
&self,
input: ListLicensesRequest,
) -> Result<ListLicensesResponse, RusotoError<ListLicensesError>>;
async fn list_received_grants(
&self,
input: ListReceivedGrantsRequest,
) -> Result<ListReceivedGrantsResponse, RusotoError<ListReceivedGrantsError>>;
async fn list_received_licenses(
&self,
input: ListReceivedLicensesRequest,
) -> Result<ListReceivedLicensesResponse, RusotoError<ListReceivedLicensesError>>;
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_tokens(
&self,
input: ListTokensRequest,
) -> Result<ListTokensResponse, RusotoError<ListTokensError>>;
async fn list_usage_for_license_configuration(
&self,
input: ListUsageForLicenseConfigurationRequest,
) -> Result<
ListUsageForLicenseConfigurationResponse,
RusotoError<ListUsageForLicenseConfigurationError>,
>;
async fn reject_grant(
&self,
input: RejectGrantRequest,
) -> Result<RejectGrantResponse, RusotoError<RejectGrantError>>;
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 accept_grant(
&self,
input: AcceptGrantRequest,
) -> Result<AcceptGrantResponse, RusotoError<AcceptGrantError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.AcceptGrant");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AcceptGrantError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AcceptGrantResponse, _>()
}
async fn check_in_license(
&self,
input: CheckInLicenseRequest,
) -> Result<CheckInLicenseResponse, RusotoError<CheckInLicenseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.CheckInLicense");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CheckInLicenseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CheckInLicenseResponse, _>()
}
async fn checkout_borrow_license(
&self,
input: CheckoutBorrowLicenseRequest,
) -> Result<CheckoutBorrowLicenseResponse, RusotoError<CheckoutBorrowLicenseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.CheckoutBorrowLicense");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CheckoutBorrowLicenseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CheckoutBorrowLicenseResponse, _>()
}
async fn checkout_license(
&self,
input: CheckoutLicenseRequest,
) -> Result<CheckoutLicenseResponse, RusotoError<CheckoutLicenseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.CheckoutLicense");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CheckoutLicenseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CheckoutLicenseResponse, _>()
}
async fn create_grant(
&self,
input: CreateGrantRequest,
) -> Result<CreateGrantResponse, RusotoError<CreateGrantError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.CreateGrant");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateGrantError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateGrantResponse, _>()
}
async fn create_grant_version(
&self,
input: CreateGrantVersionRequest,
) -> Result<CreateGrantVersionResponse, RusotoError<CreateGrantVersionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.CreateGrantVersion");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateGrantVersionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateGrantVersionResponse, _>()
}
async fn create_license(
&self,
input: CreateLicenseRequest,
) -> Result<CreateLicenseResponse, RusotoError<CreateLicenseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.CreateLicense");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLicenseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateLicenseResponse, _>()
}
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 create_license_version(
&self,
input: CreateLicenseVersionRequest,
) -> Result<CreateLicenseVersionResponse, RusotoError<CreateLicenseVersionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.CreateLicenseVersion");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateLicenseVersionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateLicenseVersionResponse, _>()
}
async fn create_token(
&self,
input: CreateTokenRequest,
) -> Result<CreateTokenResponse, RusotoError<CreateTokenError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.CreateToken");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateTokenError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateTokenResponse, _>()
}
async fn delete_grant(
&self,
input: DeleteGrantRequest,
) -> Result<DeleteGrantResponse, RusotoError<DeleteGrantError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.DeleteGrant");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteGrantError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteGrantResponse, _>()
}
async fn delete_license(
&self,
input: DeleteLicenseRequest,
) -> Result<DeleteLicenseResponse, RusotoError<DeleteLicenseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.DeleteLicense");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteLicenseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteLicenseResponse, _>()
}
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 delete_token(
&self,
input: DeleteTokenRequest,
) -> Result<DeleteTokenResponse, RusotoError<DeleteTokenError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.DeleteToken");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteTokenError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteTokenResponse, _>()
}
async fn extend_license_consumption(
&self,
input: ExtendLicenseConsumptionRequest,
) -> Result<ExtendLicenseConsumptionResponse, RusotoError<ExtendLicenseConsumptionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.ExtendLicenseConsumption");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ExtendLicenseConsumptionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ExtendLicenseConsumptionResponse, _>()
}
async fn get_access_token(
&self,
input: GetAccessTokenRequest,
) -> Result<GetAccessTokenResponse, RusotoError<GetAccessTokenError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.GetAccessToken");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetAccessTokenError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetAccessTokenResponse, _>()
}
async fn get_grant(
&self,
input: GetGrantRequest,
) -> Result<GetGrantResponse, RusotoError<GetGrantError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.GetGrant");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetGrantError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetGrantResponse, _>()
}
async fn get_license(
&self,
input: GetLicenseRequest,
) -> Result<GetLicenseResponse, RusotoError<GetLicenseError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.GetLicense");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetLicenseError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetLicenseResponse, _>()
}
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_license_usage(
&self,
input: GetLicenseUsageRequest,
) -> Result<GetLicenseUsageResponse, RusotoError<GetLicenseUsageError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.GetLicenseUsage");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetLicenseUsageError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetLicenseUsageResponse, _>()
}
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_distributed_grants(
&self,
input: ListDistributedGrantsRequest,
) -> Result<ListDistributedGrantsResponse, RusotoError<ListDistributedGrantsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.ListDistributedGrants");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListDistributedGrantsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListDistributedGrantsResponse, _>()
}
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_license_versions(
&self,
input: ListLicenseVersionsRequest,
) -> Result<ListLicenseVersionsResponse, RusotoError<ListLicenseVersionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.ListLicenseVersions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListLicenseVersionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListLicenseVersionsResponse, _>()
}
async fn list_licenses(
&self,
input: ListLicensesRequest,
) -> Result<ListLicensesResponse, RusotoError<ListLicensesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.ListLicenses");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListLicensesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListLicensesResponse, _>()
}
async fn list_received_grants(
&self,
input: ListReceivedGrantsRequest,
) -> Result<ListReceivedGrantsResponse, RusotoError<ListReceivedGrantsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.ListReceivedGrants");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListReceivedGrantsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListReceivedGrantsResponse, _>()
}
async fn list_received_licenses(
&self,
input: ListReceivedLicensesRequest,
) -> Result<ListReceivedLicensesResponse, RusotoError<ListReceivedLicensesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.ListReceivedLicenses");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListReceivedLicensesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListReceivedLicensesResponse, _>()
}
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_tokens(
&self,
input: ListTokensRequest,
) -> Result<ListTokensResponse, RusotoError<ListTokensError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.ListTokens");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTokensError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTokensResponse, _>()
}
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 reject_grant(
&self,
input: RejectGrantRequest,
) -> Result<RejectGrantResponse, RusotoError<RejectGrantError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWSLicenseManager.RejectGrant");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RejectGrantError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RejectGrantResponse, _>()
}
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, _>()
}
}