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 ServiceCatalogClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request =
SignedRequest::new(http_method, "servicecatalog", &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 AcceptPortfolioShareInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
#[serde(rename = "PortfolioShareType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_share_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AcceptPortfolioShareOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AccessLevelFilter {
#[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 AssociateBudgetWithResourceInput {
#[serde(rename = "BudgetName")]
pub budget_name: String,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateBudgetWithResourceOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociatePrincipalWithPortfolioInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
#[serde(rename = "PrincipalARN")]
pub principal_arn: String,
#[serde(rename = "PrincipalType")]
pub principal_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociatePrincipalWithPortfolioOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateProductWithPortfolioInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
#[serde(rename = "ProductId")]
pub product_id: String,
#[serde(rename = "SourcePortfolioId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_portfolio_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateProductWithPortfolioOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateServiceActionWithProvisioningArtifactInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "ProductId")]
pub product_id: String,
#[serde(rename = "ProvisioningArtifactId")]
pub provisioning_artifact_id: String,
#[serde(rename = "ServiceActionId")]
pub service_action_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateServiceActionWithProvisioningArtifactOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateTagOptionWithResourceInput {
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "TagOptionId")]
pub tag_option_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AssociateTagOptionWithResourceOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchAssociateServiceActionWithProvisioningArtifactInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "ServiceActionAssociations")]
pub service_action_associations: Vec<ServiceActionAssociation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchAssociateServiceActionWithProvisioningArtifactOutput {
#[serde(rename = "FailedServiceActionAssociations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_service_action_associations: Option<Vec<FailedServiceActionAssociation>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDisassociateServiceActionFromProvisioningArtifactInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "ServiceActionAssociations")]
pub service_action_associations: Vec<ServiceActionAssociation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDisassociateServiceActionFromProvisioningArtifactOutput {
#[serde(rename = "FailedServiceActionAssociations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_service_action_associations: Option<Vec<FailedServiceActionAssociation>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BudgetDetail {
#[serde(rename = "BudgetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub budget_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CloudWatchDashboard {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConstraintDetail {
#[serde(rename = "ConstraintId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "PortfolioId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_id: Option<String>,
#[serde(rename = "ProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_id: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConstraintSummary {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CopyProductInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "CopyOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub copy_options: Option<Vec<String>>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "SourceProductArn")]
pub source_product_arn: String,
#[serde(rename = "SourceProvisioningArtifactIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_provisioning_artifact_identifiers:
Option<Vec<::std::collections::HashMap<String, String>>>,
#[serde(rename = "TargetProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_product_id: Option<String>,
#[serde(rename = "TargetProductName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_product_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CopyProductOutput {
#[serde(rename = "CopyProductToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub copy_product_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateConstraintInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "Parameters")]
pub parameters: String,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
#[serde(rename = "ProductId")]
pub product_id: String,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateConstraintOutput {
#[serde(rename = "ConstraintDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint_detail: Option<ConstraintDetail>,
#[serde(rename = "ConstraintParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint_parameters: 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 CreatePortfolioInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisplayName")]
pub display_name: String,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "ProviderName")]
pub provider_name: String,
#[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 CreatePortfolioOutput {
#[serde(rename = "PortfolioDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_detail: Option<PortfolioDetail>,
#[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 CreatePortfolioShareInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "OrganizationNode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_node: Option<OrganizationNode>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePortfolioShareOutput {
#[serde(rename = "PortfolioShareToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_share_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateProductInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Distributor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distributor: Option<String>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Owner")]
pub owner: String,
#[serde(rename = "ProductType")]
pub product_type: String,
#[serde(rename = "ProvisioningArtifactParameters")]
pub provisioning_artifact_parameters: ProvisioningArtifactProperties,
#[serde(rename = "SupportDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_description: Option<String>,
#[serde(rename = "SupportEmail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_email: Option<String>,
#[serde(rename = "SupportUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_url: Option<String>,
#[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 CreateProductOutput {
#[serde(rename = "ProductViewDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_view_detail: Option<ProductViewDetail>,
#[serde(rename = "ProvisioningArtifactDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_detail: Option<ProvisioningArtifactDetail>,
#[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 CreateProvisionedProductPlanInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "NotificationArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_arns: Option<Vec<String>>,
#[serde(rename = "PathId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path_id: Option<String>,
#[serde(rename = "PlanName")]
pub plan_name: String,
#[serde(rename = "PlanType")]
pub plan_type: String,
#[serde(rename = "ProductId")]
pub product_id: String,
#[serde(rename = "ProvisionedProductName")]
pub provisioned_product_name: String,
#[serde(rename = "ProvisioningArtifactId")]
pub provisioning_artifact_id: String,
#[serde(rename = "ProvisioningParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_parameters: Option<Vec<UpdateProvisioningParameter>>,
#[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 CreateProvisionedProductPlanOutput {
#[serde(rename = "PlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub plan_id: Option<String>,
#[serde(rename = "PlanName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub plan_name: Option<String>,
#[serde(rename = "ProvisionProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provision_product_id: Option<String>,
#[serde(rename = "ProvisionedProductName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_name: Option<String>,
#[serde(rename = "ProvisioningArtifactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateProvisioningArtifactInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "Parameters")]
pub parameters: ProvisioningArtifactProperties,
#[serde(rename = "ProductId")]
pub product_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateProvisioningArtifactOutput {
#[serde(rename = "Info")]
#[serde(skip_serializing_if = "Option::is_none")]
pub info: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ProvisioningArtifactDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_detail: Option<ProvisioningArtifactDetail>,
#[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 CreateServiceActionInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Definition")]
pub definition: ::std::collections::HashMap<String, String>,
#[serde(rename = "DefinitionType")]
pub definition_type: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateServiceActionOutput {
#[serde(rename = "ServiceActionDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_action_detail: Option<ServiceActionDetail>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTagOptionInput {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTagOptionOutput {
#[serde(rename = "TagOptionDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_option_detail: Option<TagOptionDetail>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteConstraintInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteConstraintOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePortfolioInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeletePortfolioOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePortfolioShareInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "AccountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "OrganizationNode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_node: Option<OrganizationNode>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeletePortfolioShareOutput {
#[serde(rename = "PortfolioShareToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_share_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteProductInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteProductOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteProvisionedProductPlanInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "IgnoreErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ignore_errors: Option<bool>,
#[serde(rename = "PlanId")]
pub plan_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteProvisionedProductPlanOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteProvisioningArtifactInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "ProductId")]
pub product_id: String,
#[serde(rename = "ProvisioningArtifactId")]
pub provisioning_artifact_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteProvisioningArtifactOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteServiceActionInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteServiceActionOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTagOptionInput {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTagOptionOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeConstraintInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeConstraintOutput {
#[serde(rename = "ConstraintDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint_detail: Option<ConstraintDetail>,
#[serde(rename = "ConstraintParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint_parameters: 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 DescribeCopyProductStatusInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "CopyProductToken")]
pub copy_product_token: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeCopyProductStatusOutput {
#[serde(rename = "CopyProductStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub copy_product_status: Option<String>,
#[serde(rename = "StatusDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_detail: Option<String>,
#[serde(rename = "TargetProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_product_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePortfolioInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePortfolioOutput {
#[serde(rename = "Budgets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub budgets: Option<Vec<BudgetDetail>>,
#[serde(rename = "PortfolioDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_detail: Option<PortfolioDetail>,
#[serde(rename = "TagOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_options: Option<Vec<TagOptionDetail>>,
#[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 DescribePortfolioShareStatusInput {
#[serde(rename = "PortfolioShareToken")]
pub portfolio_share_token: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePortfolioShareStatusOutput {
#[serde(rename = "OrganizationNodeValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_node_value: Option<String>,
#[serde(rename = "PortfolioId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_id: Option<String>,
#[serde(rename = "PortfolioShareToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_share_token: Option<String>,
#[serde(rename = "ShareDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub share_details: Option<ShareDetails>,
#[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 DescribeProductAsAdminInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProductAsAdminOutput {
#[serde(rename = "Budgets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub budgets: Option<Vec<BudgetDetail>>,
#[serde(rename = "ProductViewDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_view_detail: Option<ProductViewDetail>,
#[serde(rename = "ProvisioningArtifactSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_summaries: Option<Vec<ProvisioningArtifactSummary>>,
#[serde(rename = "TagOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_options: Option<Vec<TagOptionDetail>>,
#[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 DescribeProductInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProductOutput {
#[serde(rename = "Budgets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub budgets: Option<Vec<BudgetDetail>>,
#[serde(rename = "LaunchPaths")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_paths: Option<Vec<LaunchPath>>,
#[serde(rename = "ProductViewSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_view_summary: Option<ProductViewSummary>,
#[serde(rename = "ProvisioningArtifacts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifacts: Option<Vec<ProvisioningArtifact>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeProductViewInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProductViewOutput {
#[serde(rename = "ProductViewSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_view_summary: Option<ProductViewSummary>,
#[serde(rename = "ProvisioningArtifacts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifacts: Option<Vec<ProvisioningArtifact>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeProvisionedProductInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProvisionedProductOutput {
#[serde(rename = "CloudWatchDashboards")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cloud_watch_dashboards: Option<Vec<CloudWatchDashboard>>,
#[serde(rename = "ProvisionedProductDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_detail: Option<ProvisionedProductDetail>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeProvisionedProductPlanInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "PlanId")]
pub plan_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProvisionedProductPlanOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "ProvisionedProductPlanDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_plan_details: Option<ProvisionedProductPlanDetails>,
#[serde(rename = "ResourceChanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_changes: Option<Vec<ResourceChange>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeProvisioningArtifactInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "ProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_id: Option<String>,
#[serde(rename = "ProductName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_name: Option<String>,
#[serde(rename = "ProvisioningArtifactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_id: Option<String>,
#[serde(rename = "ProvisioningArtifactName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_name: Option<String>,
#[serde(rename = "Verbose")]
#[serde(skip_serializing_if = "Option::is_none")]
pub verbose: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProvisioningArtifactOutput {
#[serde(rename = "Info")]
#[serde(skip_serializing_if = "Option::is_none")]
pub info: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ProvisioningArtifactDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_detail: Option<ProvisioningArtifactDetail>,
#[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 DescribeProvisioningParametersInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PathId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path_id: Option<String>,
#[serde(rename = "ProductId")]
pub product_id: String,
#[serde(rename = "ProvisioningArtifactId")]
pub provisioning_artifact_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeProvisioningParametersOutput {
#[serde(rename = "ConstraintSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint_summaries: Option<Vec<ConstraintSummary>>,
#[serde(rename = "ProvisioningArtifactParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_parameters: Option<Vec<ProvisioningArtifactParameter>>,
#[serde(rename = "ProvisioningArtifactPreferences")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_preferences: Option<ProvisioningArtifactPreferences>,
#[serde(rename = "TagOptions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_options: Option<Vec<TagOptionSummary>>,
#[serde(rename = "UsageInstructions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub usage_instructions: Option<Vec<UsageInstruction>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeRecordInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeRecordOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "RecordDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_detail: Option<RecordDetail>,
#[serde(rename = "RecordOutputs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_outputs: Option<Vec<RecordOutput>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeServiceActionExecutionParametersInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "ProvisionedProductId")]
pub provisioned_product_id: String,
#[serde(rename = "ServiceActionId")]
pub service_action_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeServiceActionExecutionParametersOutput {
#[serde(rename = "ServiceActionParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_action_parameters: Option<Vec<ExecutionParameter>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeServiceActionInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeServiceActionOutput {
#[serde(rename = "ServiceActionDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_action_detail: Option<ServiceActionDetail>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeTagOptionInput {
#[serde(rename = "Id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeTagOptionOutput {
#[serde(rename = "TagOptionDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_option_detail: Option<TagOptionDetail>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableAWSOrganizationsAccessInput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisableAWSOrganizationsAccessOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateBudgetFromResourceInput {
#[serde(rename = "BudgetName")]
pub budget_name: String,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateBudgetFromResourceOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociatePrincipalFromPortfolioInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
#[serde(rename = "PrincipalARN")]
pub principal_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociatePrincipalFromPortfolioOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateProductFromPortfolioInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
#[serde(rename = "ProductId")]
pub product_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateProductFromPortfolioOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateServiceActionFromProvisioningArtifactInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "ProductId")]
pub product_id: String,
#[serde(rename = "ProvisioningArtifactId")]
pub provisioning_artifact_id: String,
#[serde(rename = "ServiceActionId")]
pub service_action_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateServiceActionFromProvisioningArtifactOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateTagOptionFromResourceInput {
#[serde(rename = "ResourceId")]
pub resource_id: String,
#[serde(rename = "TagOptionId")]
pub tag_option_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisassociateTagOptionFromResourceOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableAWSOrganizationsAccessInput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnableAWSOrganizationsAccessOutput {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ExecuteProvisionedProductPlanInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "PlanId")]
pub plan_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExecuteProvisionedProductPlanOutput {
#[serde(rename = "RecordDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_detail: Option<RecordDetail>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ExecuteProvisionedProductServiceActionInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "ExecuteToken")]
pub execute_token: String,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, Vec<String>>>,
#[serde(rename = "ProvisionedProductId")]
pub provisioned_product_id: String,
#[serde(rename = "ServiceActionId")]
pub service_action_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExecuteProvisionedProductServiceActionOutput {
#[serde(rename = "RecordDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_detail: Option<RecordDetail>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ExecutionParameter {
#[serde(rename = "DefaultValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_values: Option<Vec<String>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FailedServiceActionAssociation {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "ErrorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "ProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_id: Option<String>,
#[serde(rename = "ProvisioningArtifactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_id: Option<String>,
#[serde(rename = "ServiceActionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_action_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAWSOrganizationsAccessStatusInput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAWSOrganizationsAccessStatusOutput {
#[serde(rename = "AccessStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LaunchPath {
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LaunchPathSummary {
#[serde(rename = "ConstraintSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint_summaries: Option<Vec<ConstraintSummary>>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: 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 ListAcceptedPortfolioSharesInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "PortfolioShareType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_share_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAcceptedPortfolioSharesOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "PortfolioDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_details: Option<Vec<PortfolioDetail>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBudgetsForResourceInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "ResourceId")]
pub resource_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBudgetsForResourceOutput {
#[serde(rename = "Budgets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub budgets: Option<Vec<BudgetDetail>>,
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListConstraintsForPortfolioInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
#[serde(rename = "ProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListConstraintsForPortfolioOutput {
#[serde(rename = "ConstraintDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint_details: Option<Vec<ConstraintDetail>>,
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLaunchPathsInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "ProductId")]
pub product_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLaunchPathsOutput {
#[serde(rename = "LaunchPathSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub launch_path_summaries: Option<Vec<LaunchPathSummary>>,
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListOrganizationPortfolioAccessInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "OrganizationNodeType")]
pub organization_node_type: String,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListOrganizationPortfolioAccessOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "OrganizationNodes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_nodes: Option<Vec<OrganizationNode>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPortfolioAccessInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "OrganizationParentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_parent_id: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPortfolioAccessOutput {
#[serde(rename = "AccountIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_ids: Option<Vec<String>>,
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPortfoliosForProductInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "ProductId")]
pub product_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPortfoliosForProductOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "PortfolioDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_details: Option<Vec<PortfolioDetail>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPortfoliosInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPortfoliosOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "PortfolioDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_details: Option<Vec<PortfolioDetail>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPrincipalsForPortfolioInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPrincipalsForPortfolioOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "Principals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principals: Option<Vec<Principal>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProvisionedProductPlansInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "AccessLevelFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_level_filter: Option<AccessLevelFilter>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "ProvisionProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provision_product_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListProvisionedProductPlansOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "ProvisionedProductPlans")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_plans: Option<Vec<ProvisionedProductPlanSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProvisioningArtifactsForServiceActionInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "ServiceActionId")]
pub service_action_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListProvisioningArtifactsForServiceActionOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "ProvisioningArtifactViews")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_views: Option<Vec<ProvisioningArtifactView>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProvisioningArtifactsInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "ProductId")]
pub product_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListProvisioningArtifactsOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "ProvisioningArtifactDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_details: Option<Vec<ProvisioningArtifactDetail>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRecordHistoryInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "AccessLevelFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_level_filter: Option<AccessLevelFilter>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "SearchFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub search_filter: Option<ListRecordHistorySearchFilter>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRecordHistoryOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "RecordDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_details: Option<Vec<RecordDetail>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRecordHistorySearchFilter {
#[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 ListResourcesForTagOptionInput {
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "TagOptionId")]
pub tag_option_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResourcesForTagOptionOutput {
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "ResourceDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_details: Option<Vec<ResourceDetail>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListServiceActionsForProvisioningArtifactInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "ProductId")]
pub product_id: String,
#[serde(rename = "ProvisioningArtifactId")]
pub provisioning_artifact_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListServiceActionsForProvisioningArtifactOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "ServiceActionSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_action_summaries: Option<Vec<ServiceActionSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListServiceActionsInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListServiceActionsOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "ServiceActionSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_action_summaries: Option<Vec<ServiceActionSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListStackInstancesForProvisionedProductInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "ProvisionedProductId")]
pub provisioned_product_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListStackInstancesForProvisionedProductOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "StackInstances")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_instances: Option<Vec<StackInstance>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagOptionsFilters {
#[serde(rename = "Active")]
#[serde(skip_serializing_if = "Option::is_none")]
pub active: Option<bool>,
#[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 ListTagOptionsInput {
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<ListTagOptionsFilters>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagOptionsOutput {
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "TagOptionDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_option_details: Option<Vec<TagOptionDetail>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OrganizationNode {
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<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 ParameterConstraints {
#[serde(rename = "AllowedValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_values: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PortfolioDetail {
#[serde(rename = "ARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "ProviderName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Principal {
#[serde(rename = "PrincipalARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal_arn: Option<String>,
#[serde(rename = "PrincipalType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub principal_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProductViewAggregationValue {
#[serde(rename = "ApproximateCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approximate_count: Option<i64>,
#[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 ProductViewDetail {
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "ProductARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_arn: Option<String>,
#[serde(rename = "ProductViewSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_view_summary: Option<ProductViewSummary>,
#[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 ProductViewSummary {
#[serde(rename = "Distributor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distributor: Option<String>,
#[serde(rename = "HasDefaultPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub has_default_path: Option<bool>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "ProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_id: Option<String>,
#[serde(rename = "ShortDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub short_description: Option<String>,
#[serde(rename = "SupportDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_description: Option<String>,
#[serde(rename = "SupportEmail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_email: Option<String>,
#[serde(rename = "SupportUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_url: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ProvisionProductInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "NotificationArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_arns: Option<Vec<String>>,
#[serde(rename = "PathId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path_id: Option<String>,
#[serde(rename = "ProductId")]
pub product_id: String,
#[serde(rename = "ProvisionToken")]
pub provision_token: String,
#[serde(rename = "ProvisionedProductName")]
pub provisioned_product_name: String,
#[serde(rename = "ProvisioningArtifactId")]
pub provisioning_artifact_id: String,
#[serde(rename = "ProvisioningParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_parameters: Option<Vec<ProvisioningParameter>>,
#[serde(rename = "ProvisioningPreferences")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_preferences: Option<ProvisioningPreferences>,
#[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 ProvisionProductOutput {
#[serde(rename = "RecordDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_detail: Option<RecordDetail>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisionedProductAttribute {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "IdempotencyToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub idempotency_token: Option<String>,
#[serde(rename = "LastRecordId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_record_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "PhysicalId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub physical_id: Option<String>,
#[serde(rename = "ProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_id: Option<String>,
#[serde(rename = "ProvisioningArtifactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "UserArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_arn: Option<String>,
#[serde(rename = "UserArnSession")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_arn_session: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisionedProductDetail {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "IdempotencyToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub idempotency_token: Option<String>,
#[serde(rename = "LastRecordId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_record_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_id: Option<String>,
#[serde(rename = "ProvisioningArtifactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_id: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisionedProductPlanDetails {
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "NotificationArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub notification_arns: Option<Vec<String>>,
#[serde(rename = "PathId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path_id: Option<String>,
#[serde(rename = "PlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub plan_id: Option<String>,
#[serde(rename = "PlanName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub plan_name: Option<String>,
#[serde(rename = "PlanType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub plan_type: Option<String>,
#[serde(rename = "ProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_id: Option<String>,
#[serde(rename = "ProvisionProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provision_product_id: Option<String>,
#[serde(rename = "ProvisionProductName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provision_product_name: Option<String>,
#[serde(rename = "ProvisioningArtifactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_id: Option<String>,
#[serde(rename = "ProvisioningParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_parameters: Option<Vec<UpdateProvisioningParameter>>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_message: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "UpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisionedProductPlanSummary {
#[serde(rename = "PlanId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub plan_id: Option<String>,
#[serde(rename = "PlanName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub plan_name: Option<String>,
#[serde(rename = "PlanType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub plan_type: Option<String>,
#[serde(rename = "ProvisionProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provision_product_id: Option<String>,
#[serde(rename = "ProvisionProductName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provision_product_name: Option<String>,
#[serde(rename = "ProvisioningArtifactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisioningArtifact {
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Guidance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub guidance: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisioningArtifactDetail {
#[serde(rename = "Active")]
#[serde(skip_serializing_if = "Option::is_none")]
pub active: Option<bool>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Guidance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub guidance: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisioningArtifactParameter {
#[serde(rename = "DefaultValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_value: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IsNoEcho")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_no_echo: Option<bool>,
#[serde(rename = "ParameterConstraints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameter_constraints: Option<ParameterConstraints>,
#[serde(rename = "ParameterKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameter_key: Option<String>,
#[serde(rename = "ParameterType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameter_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisioningArtifactPreferences {
#[serde(rename = "StackSetAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_accounts: Option<Vec<String>>,
#[serde(rename = "StackSetRegions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_regions: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ProvisioningArtifactProperties {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisableTemplateValidation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_template_validation: Option<bool>,
#[serde(rename = "Info")]
pub info: ::std::collections::HashMap<String, String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisioningArtifactSummary {
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ProvisioningArtifactMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_metadata: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisioningArtifactView {
#[serde(rename = "ProductViewSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_view_summary: Option<ProductViewSummary>,
#[serde(rename = "ProvisioningArtifact")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact: Option<ProvisioningArtifact>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ProvisioningParameter {
#[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 ProvisioningPreferences {
#[serde(rename = "StackSetAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_accounts: Option<Vec<String>>,
#[serde(rename = "StackSetFailureToleranceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_failure_tolerance_count: Option<i64>,
#[serde(rename = "StackSetFailureTolerancePercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_failure_tolerance_percentage: Option<i64>,
#[serde(rename = "StackSetMaxConcurrencyCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_max_concurrency_count: Option<i64>,
#[serde(rename = "StackSetMaxConcurrencyPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_max_concurrency_percentage: Option<i64>,
#[serde(rename = "StackSetRegions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_regions: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecordDetail {
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "PathId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path_id: Option<String>,
#[serde(rename = "ProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_id: Option<String>,
#[serde(rename = "ProvisionedProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_id: Option<String>,
#[serde(rename = "ProvisionedProductName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_name: Option<String>,
#[serde(rename = "ProvisionedProductType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_type: Option<String>,
#[serde(rename = "ProvisioningArtifactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_id: Option<String>,
#[serde(rename = "RecordErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_errors: Option<Vec<RecordError>>,
#[serde(rename = "RecordId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_id: Option<String>,
#[serde(rename = "RecordTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_tags: Option<Vec<RecordTag>>,
#[serde(rename = "RecordType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_type: Option<String>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "UpdatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub updated_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecordError {
#[serde(rename = "Code")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecordOutput {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "OutputKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_key: Option<String>,
#[serde(rename = "OutputValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub output_value: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RecordTag {
#[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 RejectPortfolioShareInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PortfolioId")]
pub portfolio_id: String,
#[serde(rename = "PortfolioShareType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_share_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RejectPortfolioShareOutput {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceChange {
#[serde(rename = "Action")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action: Option<String>,
#[serde(rename = "Details")]
#[serde(skip_serializing_if = "Option::is_none")]
pub details: Option<Vec<ResourceChangeDetail>>,
#[serde(rename = "LogicalResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logical_resource_id: Option<String>,
#[serde(rename = "PhysicalResourceId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub physical_resource_id: Option<String>,
#[serde(rename = "Replacement")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replacement: Option<String>,
#[serde(rename = "ResourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resource_type: Option<String>,
#[serde(rename = "Scope")]
#[serde(skip_serializing_if = "Option::is_none")]
pub scope: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceChangeDetail {
#[serde(rename = "CausingEntity")]
#[serde(skip_serializing_if = "Option::is_none")]
pub causing_entity: Option<String>,
#[serde(rename = "Evaluation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub evaluation: Option<String>,
#[serde(rename = "Target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<ResourceTargetDefinition>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceDetail {
#[serde(rename = "ARN")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CreatedTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_time: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ResourceTargetDefinition {
#[serde(rename = "Attribute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RequiresRecreation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requires_recreation: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ScanProvisionedProductsInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "AccessLevelFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_level_filter: Option<AccessLevelFilter>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ScanProvisionedProductsOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "ProvisionedProducts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_products: Option<Vec<ProvisionedProductDetail>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SearchProductsAsAdminInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<::std::collections::HashMap<String, Vec<String>>>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "PortfolioId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_id: Option<String>,
#[serde(rename = "ProductSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_source: Option<String>,
#[serde(rename = "SortBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_by: Option<String>,
#[serde(rename = "SortOrder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_order: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SearchProductsAsAdminOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "ProductViewDetails")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_view_details: Option<Vec<ProductViewDetail>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SearchProductsInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<::std::collections::HashMap<String, Vec<String>>>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "SortBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_by: Option<String>,
#[serde(rename = "SortOrder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_order: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SearchProductsOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "ProductViewAggregations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_view_aggregations:
Option<::std::collections::HashMap<String, Vec<ProductViewAggregationValue>>>,
#[serde(rename = "ProductViewSummaries")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_view_summaries: Option<Vec<ProductViewSummary>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SearchProvisionedProductsInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "AccessLevelFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_level_filter: Option<AccessLevelFilter>,
#[serde(rename = "Filters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filters: Option<::std::collections::HashMap<String, Vec<String>>>,
#[serde(rename = "PageSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_size: Option<i64>,
#[serde(rename = "PageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub page_token: Option<String>,
#[serde(rename = "SortBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_by: Option<String>,
#[serde(rename = "SortOrder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_order: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SearchProvisionedProductsOutput {
#[serde(rename = "NextPageToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_page_token: Option<String>,
#[serde(rename = "ProvisionedProducts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_products: Option<Vec<ProvisionedProductAttribute>>,
#[serde(rename = "TotalResultsCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_results_count: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ServiceActionAssociation {
#[serde(rename = "ProductId")]
pub product_id: String,
#[serde(rename = "ProvisioningArtifactId")]
pub provisioning_artifact_id: String,
#[serde(rename = "ServiceActionId")]
pub service_action_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ServiceActionDetail {
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ServiceActionSummary")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_action_summary: Option<ServiceActionSummary>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ServiceActionSummary {
#[serde(rename = "DefinitionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition_type: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ShareDetails {
#[serde(rename = "ShareErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub share_errors: Option<Vec<ShareError>>,
#[serde(rename = "SuccessfulShares")]
#[serde(skip_serializing_if = "Option::is_none")]
pub successful_shares: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ShareError {
#[serde(rename = "Accounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accounts: Option<Vec<String>>,
#[serde(rename = "Error")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error: Option<String>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StackInstance {
#[serde(rename = "Account")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account: Option<String>,
#[serde(rename = "Region")]
#[serde(skip_serializing_if = "Option::is_none")]
pub region: Option<String>,
#[serde(rename = "StackInstanceStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_instance_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
pub key: String,
#[serde(rename = "Value")]
pub value: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagOptionDetail {
#[serde(rename = "Active")]
#[serde(skip_serializing_if = "Option::is_none")]
pub active: Option<bool>,
#[serde(rename = "Id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
#[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, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagOptionSummary {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: 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 TerminateProvisionedProductInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "IgnoreErrors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ignore_errors: Option<bool>,
#[serde(rename = "ProvisionedProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_id: Option<String>,
#[serde(rename = "ProvisionedProductName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_name: Option<String>,
#[serde(rename = "TerminateToken")]
pub terminate_token: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TerminateProvisionedProductOutput {
#[serde(rename = "RecordDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_detail: Option<RecordDetail>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateConstraintInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateConstraintOutput {
#[serde(rename = "ConstraintDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint_detail: Option<ConstraintDetail>,
#[serde(rename = "ConstraintParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub constraint_parameters: 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 UpdatePortfolioInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "AddTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_tags: Option<Vec<Tag>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisplayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "ProviderName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provider_name: Option<String>,
#[serde(rename = "RemoveTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_tags: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdatePortfolioOutput {
#[serde(rename = "PortfolioDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub portfolio_detail: Option<PortfolioDetail>,
#[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 UpdateProductInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "AddTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_tags: Option<Vec<Tag>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Distributor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub distributor: Option<String>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Owner")]
#[serde(skip_serializing_if = "Option::is_none")]
pub owner: Option<String>,
#[serde(rename = "RemoveTags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_tags: Option<Vec<String>>,
#[serde(rename = "SupportDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_description: Option<String>,
#[serde(rename = "SupportEmail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_email: Option<String>,
#[serde(rename = "SupportUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub support_url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateProductOutput {
#[serde(rename = "ProductViewDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_view_detail: Option<ProductViewDetail>,
#[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 UpdateProvisionedProductInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "PathId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path_id: Option<String>,
#[serde(rename = "ProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub product_id: Option<String>,
#[serde(rename = "ProvisionedProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_id: Option<String>,
#[serde(rename = "ProvisionedProductName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_name: Option<String>,
#[serde(rename = "ProvisioningArtifactId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_id: Option<String>,
#[serde(rename = "ProvisioningParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_parameters: Option<Vec<UpdateProvisioningParameter>>,
#[serde(rename = "ProvisioningPreferences")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_preferences: Option<UpdateProvisioningPreferences>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<Vec<Tag>>,
#[serde(rename = "UpdateToken")]
pub update_token: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateProvisionedProductOutput {
#[serde(rename = "RecordDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_detail: Option<RecordDetail>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateProvisionedProductPropertiesInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "IdempotencyToken")]
pub idempotency_token: String,
#[serde(rename = "ProvisionedProductId")]
pub provisioned_product_id: String,
#[serde(rename = "ProvisionedProductProperties")]
pub provisioned_product_properties: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateProvisionedProductPropertiesOutput {
#[serde(rename = "ProvisionedProductId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_id: Option<String>,
#[serde(rename = "ProvisionedProductProperties")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_product_properties: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RecordId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub record_id: 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 UpdateProvisioningArtifactInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Active")]
#[serde(skip_serializing_if = "Option::is_none")]
pub active: Option<bool>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Guidance")]
#[serde(skip_serializing_if = "Option::is_none")]
pub guidance: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ProductId")]
pub product_id: String,
#[serde(rename = "ProvisioningArtifactId")]
pub provisioning_artifact_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateProvisioningArtifactOutput {
#[serde(rename = "Info")]
#[serde(skip_serializing_if = "Option::is_none")]
pub info: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ProvisioningArtifactDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioning_artifact_detail: Option<ProvisioningArtifactDetail>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct UpdateProvisioningParameter {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "UsePreviousValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_previous_value: Option<bool>,
#[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 UpdateProvisioningPreferences {
#[serde(rename = "StackSetAccounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_accounts: Option<Vec<String>>,
#[serde(rename = "StackSetFailureToleranceCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_failure_tolerance_count: Option<i64>,
#[serde(rename = "StackSetFailureTolerancePercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_failure_tolerance_percentage: Option<i64>,
#[serde(rename = "StackSetMaxConcurrencyCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_max_concurrency_count: Option<i64>,
#[serde(rename = "StackSetMaxConcurrencyPercentage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_max_concurrency_percentage: Option<i64>,
#[serde(rename = "StackSetOperationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_operation_type: Option<String>,
#[serde(rename = "StackSetRegions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_set_regions: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateServiceActionInput {
#[serde(rename = "AcceptLanguage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub accept_language: Option<String>,
#[serde(rename = "Definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Id")]
pub id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateServiceActionOutput {
#[serde(rename = "ServiceActionDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_action_detail: Option<ServiceActionDetail>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateTagOptionInput {
#[serde(rename = "Active")]
#[serde(skip_serializing_if = "Option::is_none")]
pub active: Option<bool>,
#[serde(rename = "Id")]
pub id: 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 UpdateTagOptionOutput {
#[serde(rename = "TagOptionDetail")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tag_option_detail: Option<TagOptionDetail>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UsageInstruction {
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AcceptPortfolioShareError {
InvalidParameters(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl AcceptPortfolioShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AcceptPortfolioShareError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(AcceptPortfolioShareError::InvalidParameters(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(AcceptPortfolioShareError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AcceptPortfolioShareError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AcceptPortfolioShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AcceptPortfolioShareError::InvalidParameters(ref cause) => write!(f, "{}", cause),
AcceptPortfolioShareError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AcceptPortfolioShareError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AcceptPortfolioShareError {}
#[derive(Debug, PartialEq)]
pub enum AssociateBudgetWithResourceError {
DuplicateResource(String),
InvalidParameters(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl AssociateBudgetWithResourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateBudgetWithResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DuplicateResourceException" => {
return RusotoError::Service(
AssociateBudgetWithResourceError::DuplicateResource(err.msg),
)
}
"InvalidParametersException" => {
return RusotoError::Service(
AssociateBudgetWithResourceError::InvalidParameters(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(AssociateBudgetWithResourceError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AssociateBudgetWithResourceError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateBudgetWithResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateBudgetWithResourceError::DuplicateResource(ref cause) => {
write!(f, "{}", cause)
}
AssociateBudgetWithResourceError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
AssociateBudgetWithResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AssociateBudgetWithResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AssociateBudgetWithResourceError {}
#[derive(Debug, PartialEq)]
pub enum AssociatePrincipalWithPortfolioError {
InvalidParameters(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl AssociatePrincipalWithPortfolioError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociatePrincipalWithPortfolioError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
AssociatePrincipalWithPortfolioError::InvalidParameters(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(
AssociatePrincipalWithPortfolioError::LimitExceeded(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AssociatePrincipalWithPortfolioError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociatePrincipalWithPortfolioError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociatePrincipalWithPortfolioError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
AssociatePrincipalWithPortfolioError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
AssociatePrincipalWithPortfolioError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociatePrincipalWithPortfolioError {}
#[derive(Debug, PartialEq)]
pub enum AssociateProductWithPortfolioError {
InvalidParameters(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl AssociateProductWithPortfolioError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateProductWithPortfolioError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
AssociateProductWithPortfolioError::InvalidParameters(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(AssociateProductWithPortfolioError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AssociateProductWithPortfolioError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateProductWithPortfolioError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateProductWithPortfolioError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
AssociateProductWithPortfolioError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AssociateProductWithPortfolioError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateProductWithPortfolioError {}
#[derive(Debug, PartialEq)]
pub enum AssociateServiceActionWithProvisioningArtifactError {
DuplicateResource(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl AssociateServiceActionWithProvisioningArtifactError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateServiceActionWithProvisioningArtifactError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DuplicateResourceException" => {
return RusotoError::Service(
AssociateServiceActionWithProvisioningArtifactError::DuplicateResource(
err.msg,
),
)
}
"LimitExceededException" => {
return RusotoError::Service(
AssociateServiceActionWithProvisioningArtifactError::LimitExceeded(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AssociateServiceActionWithProvisioningArtifactError::ResourceNotFound(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateServiceActionWithProvisioningArtifactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateServiceActionWithProvisioningArtifactError::DuplicateResource(ref cause) => {
write!(f, "{}", cause)
}
AssociateServiceActionWithProvisioningArtifactError::LimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
AssociateServiceActionWithProvisioningArtifactError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateServiceActionWithProvisioningArtifactError {}
#[derive(Debug, PartialEq)]
pub enum AssociateTagOptionWithResourceError {
DuplicateResource(String),
InvalidParameters(String),
InvalidState(String),
LimitExceeded(String),
ResourceNotFound(String),
TagOptionNotMigrated(String),
}
impl AssociateTagOptionWithResourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateTagOptionWithResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DuplicateResourceException" => {
return RusotoError::Service(
AssociateTagOptionWithResourceError::DuplicateResource(err.msg),
)
}
"InvalidParametersException" => {
return RusotoError::Service(
AssociateTagOptionWithResourceError::InvalidParameters(err.msg),
)
}
"InvalidStateException" => {
return RusotoError::Service(AssociateTagOptionWithResourceError::InvalidState(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(
AssociateTagOptionWithResourceError::LimitExceeded(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
AssociateTagOptionWithResourceError::ResourceNotFound(err.msg),
)
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(
AssociateTagOptionWithResourceError::TagOptionNotMigrated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateTagOptionWithResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateTagOptionWithResourceError::DuplicateResource(ref cause) => {
write!(f, "{}", cause)
}
AssociateTagOptionWithResourceError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
AssociateTagOptionWithResourceError::InvalidState(ref cause) => write!(f, "{}", cause),
AssociateTagOptionWithResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AssociateTagOptionWithResourceError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
AssociateTagOptionWithResourceError::TagOptionNotMigrated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for AssociateTagOptionWithResourceError {}
#[derive(Debug, PartialEq)]
pub enum BatchAssociateServiceActionWithProvisioningArtifactError {
InvalidParameters(String),
}
impl BatchAssociateServiceActionWithProvisioningArtifactError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchAssociateServiceActionWithProvisioningArtifactError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
BatchAssociateServiceActionWithProvisioningArtifactError::InvalidParameters(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchAssociateServiceActionWithProvisioningArtifactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchAssociateServiceActionWithProvisioningArtifactError::InvalidParameters(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for BatchAssociateServiceActionWithProvisioningArtifactError {}
#[derive(Debug, PartialEq)]
pub enum BatchDisassociateServiceActionFromProvisioningArtifactError {
InvalidParameters(String),
}
impl BatchDisassociateServiceActionFromProvisioningArtifactError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchDisassociateServiceActionFromProvisioningArtifactError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => return RusotoError::Service(
BatchDisassociateServiceActionFromProvisioningArtifactError::InvalidParameters(
err.msg,
),
),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchDisassociateServiceActionFromProvisioningArtifactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchDisassociateServiceActionFromProvisioningArtifactError::InvalidParameters(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for BatchDisassociateServiceActionFromProvisioningArtifactError {}
#[derive(Debug, PartialEq)]
pub enum CopyProductError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl CopyProductError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CopyProductError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(CopyProductError::InvalidParameters(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CopyProductError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CopyProductError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CopyProductError::InvalidParameters(ref cause) => write!(f, "{}", cause),
CopyProductError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CopyProductError {}
#[derive(Debug, PartialEq)]
pub enum CreateConstraintError {
DuplicateResource(String),
InvalidParameters(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl CreateConstraintError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateConstraintError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DuplicateResourceException" => {
return RusotoError::Service(CreateConstraintError::DuplicateResource(err.msg))
}
"InvalidParametersException" => {
return RusotoError::Service(CreateConstraintError::InvalidParameters(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateConstraintError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateConstraintError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateConstraintError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateConstraintError::DuplicateResource(ref cause) => write!(f, "{}", cause),
CreateConstraintError::InvalidParameters(ref cause) => write!(f, "{}", cause),
CreateConstraintError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateConstraintError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateConstraintError {}
#[derive(Debug, PartialEq)]
pub enum CreatePortfolioError {
InvalidParameters(String),
LimitExceeded(String),
TagOptionNotMigrated(String),
}
impl CreatePortfolioError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePortfolioError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(CreatePortfolioError::InvalidParameters(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreatePortfolioError::LimitExceeded(err.msg))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(CreatePortfolioError::TagOptionNotMigrated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePortfolioError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePortfolioError::InvalidParameters(ref cause) => write!(f, "{}", cause),
CreatePortfolioError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreatePortfolioError::TagOptionNotMigrated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePortfolioError {}
#[derive(Debug, PartialEq)]
pub enum CreatePortfolioShareError {
InvalidParameters(String),
InvalidState(String),
LimitExceeded(String),
OperationNotSupported(String),
ResourceNotFound(String),
}
impl CreatePortfolioShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePortfolioShareError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(CreatePortfolioShareError::InvalidParameters(
err.msg,
))
}
"InvalidStateException" => {
return RusotoError::Service(CreatePortfolioShareError::InvalidState(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreatePortfolioShareError::LimitExceeded(err.msg))
}
"OperationNotSupportedException" => {
return RusotoError::Service(CreatePortfolioShareError::OperationNotSupported(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreatePortfolioShareError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePortfolioShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePortfolioShareError::InvalidParameters(ref cause) => write!(f, "{}", cause),
CreatePortfolioShareError::InvalidState(ref cause) => write!(f, "{}", cause),
CreatePortfolioShareError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreatePortfolioShareError::OperationNotSupported(ref cause) => write!(f, "{}", cause),
CreatePortfolioShareError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePortfolioShareError {}
#[derive(Debug, PartialEq)]
pub enum CreateProductError {
InvalidParameters(String),
LimitExceeded(String),
TagOptionNotMigrated(String),
}
impl CreateProductError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateProductError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(CreateProductError::InvalidParameters(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateProductError::LimitExceeded(err.msg))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(CreateProductError::TagOptionNotMigrated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateProductError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateProductError::InvalidParameters(ref cause) => write!(f, "{}", cause),
CreateProductError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateProductError::TagOptionNotMigrated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateProductError {}
#[derive(Debug, PartialEq)]
pub enum CreateProvisionedProductPlanError {
InvalidParameters(String),
InvalidState(String),
ResourceNotFound(String),
}
impl CreateProvisionedProductPlanError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateProvisionedProductPlanError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
CreateProvisionedProductPlanError::InvalidParameters(err.msg),
)
}
"InvalidStateException" => {
return RusotoError::Service(CreateProvisionedProductPlanError::InvalidState(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
CreateProvisionedProductPlanError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateProvisionedProductPlanError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateProvisionedProductPlanError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
CreateProvisionedProductPlanError::InvalidState(ref cause) => write!(f, "{}", cause),
CreateProvisionedProductPlanError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateProvisionedProductPlanError {}
#[derive(Debug, PartialEq)]
pub enum CreateProvisioningArtifactError {
InvalidParameters(String),
LimitExceeded(String),
ResourceNotFound(String),
}
impl CreateProvisioningArtifactError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateProvisioningArtifactError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
CreateProvisioningArtifactError::InvalidParameters(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(CreateProvisioningArtifactError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateProvisioningArtifactError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateProvisioningArtifactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateProvisioningArtifactError::InvalidParameters(ref cause) => write!(f, "{}", cause),
CreateProvisioningArtifactError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateProvisioningArtifactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateProvisioningArtifactError {}
#[derive(Debug, PartialEq)]
pub enum CreateServiceActionError {
InvalidParameters(String),
LimitExceeded(String),
}
impl CreateServiceActionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateServiceActionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(CreateServiceActionError::InvalidParameters(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateServiceActionError::LimitExceeded(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateServiceActionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateServiceActionError::InvalidParameters(ref cause) => write!(f, "{}", cause),
CreateServiceActionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateServiceActionError {}
#[derive(Debug, PartialEq)]
pub enum CreateTagOptionError {
DuplicateResource(String),
LimitExceeded(String),
TagOptionNotMigrated(String),
}
impl CreateTagOptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTagOptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DuplicateResourceException" => {
return RusotoError::Service(CreateTagOptionError::DuplicateResource(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateTagOptionError::LimitExceeded(err.msg))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(CreateTagOptionError::TagOptionNotMigrated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTagOptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTagOptionError::DuplicateResource(ref cause) => write!(f, "{}", cause),
CreateTagOptionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateTagOptionError::TagOptionNotMigrated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTagOptionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteConstraintError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl DeleteConstraintError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteConstraintError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(DeleteConstraintError::InvalidParameters(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteConstraintError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteConstraintError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteConstraintError::InvalidParameters(ref cause) => write!(f, "{}", cause),
DeleteConstraintError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteConstraintError {}
#[derive(Debug, PartialEq)]
pub enum DeletePortfolioError {
InvalidParameters(String),
ResourceInUse(String),
ResourceNotFound(String),
TagOptionNotMigrated(String),
}
impl DeletePortfolioError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeletePortfolioError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(DeletePortfolioError::InvalidParameters(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeletePortfolioError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeletePortfolioError::ResourceNotFound(err.msg))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(DeletePortfolioError::TagOptionNotMigrated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeletePortfolioError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePortfolioError::InvalidParameters(ref cause) => write!(f, "{}", cause),
DeletePortfolioError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeletePortfolioError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeletePortfolioError::TagOptionNotMigrated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeletePortfolioError {}
#[derive(Debug, PartialEq)]
pub enum DeletePortfolioShareError {
InvalidParameters(String),
InvalidState(String),
OperationNotSupported(String),
ResourceNotFound(String),
}
impl DeletePortfolioShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeletePortfolioShareError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(DeletePortfolioShareError::InvalidParameters(
err.msg,
))
}
"InvalidStateException" => {
return RusotoError::Service(DeletePortfolioShareError::InvalidState(err.msg))
}
"OperationNotSupportedException" => {
return RusotoError::Service(DeletePortfolioShareError::OperationNotSupported(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeletePortfolioShareError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeletePortfolioShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePortfolioShareError::InvalidParameters(ref cause) => write!(f, "{}", cause),
DeletePortfolioShareError::InvalidState(ref cause) => write!(f, "{}", cause),
DeletePortfolioShareError::OperationNotSupported(ref cause) => write!(f, "{}", cause),
DeletePortfolioShareError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeletePortfolioShareError {}
#[derive(Debug, PartialEq)]
pub enum DeleteProductError {
InvalidParameters(String),
ResourceInUse(String),
ResourceNotFound(String),
TagOptionNotMigrated(String),
}
impl DeleteProductError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteProductError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(DeleteProductError::InvalidParameters(err.msg))
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteProductError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteProductError::ResourceNotFound(err.msg))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(DeleteProductError::TagOptionNotMigrated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteProductError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteProductError::InvalidParameters(ref cause) => write!(f, "{}", cause),
DeleteProductError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteProductError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteProductError::TagOptionNotMigrated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteProductError {}
#[derive(Debug, PartialEq)]
pub enum DeleteProvisionedProductPlanError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl DeleteProvisionedProductPlanError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteProvisionedProductPlanError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
DeleteProvisionedProductPlanError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteProvisionedProductPlanError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteProvisionedProductPlanError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteProvisionedProductPlanError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
DeleteProvisionedProductPlanError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteProvisionedProductPlanError {}
#[derive(Debug, PartialEq)]
pub enum DeleteProvisioningArtifactError {
InvalidParameters(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteProvisioningArtifactError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteProvisioningArtifactError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
DeleteProvisioningArtifactError::InvalidParameters(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteProvisioningArtifactError::ResourceInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteProvisioningArtifactError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteProvisioningArtifactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteProvisioningArtifactError::InvalidParameters(ref cause) => write!(f, "{}", cause),
DeleteProvisioningArtifactError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteProvisioningArtifactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteProvisioningArtifactError {}
#[derive(Debug, PartialEq)]
pub enum DeleteServiceActionError {
ResourceInUse(String),
ResourceNotFound(String),
}
impl DeleteServiceActionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteServiceActionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceInUseException" => {
return RusotoError::Service(DeleteServiceActionError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteServiceActionError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteServiceActionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteServiceActionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteServiceActionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteServiceActionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTagOptionError {
ResourceInUse(String),
ResourceNotFound(String),
TagOptionNotMigrated(String),
}
impl DeleteTagOptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTagOptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceInUseException" => {
return RusotoError::Service(DeleteTagOptionError::ResourceInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteTagOptionError::ResourceNotFound(err.msg))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(DeleteTagOptionError::TagOptionNotMigrated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTagOptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTagOptionError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteTagOptionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteTagOptionError::TagOptionNotMigrated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTagOptionError {}
#[derive(Debug, PartialEq)]
pub enum DescribeConstraintError {
ResourceNotFound(String),
}
impl DescribeConstraintError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeConstraintError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeConstraintError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeConstraintError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeConstraintError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeConstraintError {}
#[derive(Debug, PartialEq)]
pub enum DescribeCopyProductStatusError {
ResourceNotFound(String),
}
impl DescribeCopyProductStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeCopyProductStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeCopyProductStatusError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeCopyProductStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeCopyProductStatusError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeCopyProductStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribePortfolioError {
ResourceNotFound(String),
}
impl DescribePortfolioError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePortfolioError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(DescribePortfolioError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribePortfolioError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribePortfolioError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribePortfolioError {}
#[derive(Debug, PartialEq)]
pub enum DescribePortfolioShareStatusError {
InvalidParameters(String),
OperationNotSupported(String),
ResourceNotFound(String),
}
impl DescribePortfolioShareStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribePortfolioShareStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
DescribePortfolioShareStatusError::InvalidParameters(err.msg),
)
}
"OperationNotSupportedException" => {
return RusotoError::Service(
DescribePortfolioShareStatusError::OperationNotSupported(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribePortfolioShareStatusError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribePortfolioShareStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribePortfolioShareStatusError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
DescribePortfolioShareStatusError::OperationNotSupported(ref cause) => {
write!(f, "{}", cause)
}
DescribePortfolioShareStatusError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribePortfolioShareStatusError {}
#[derive(Debug, PartialEq)]
pub enum DescribeProductError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl DescribeProductError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeProductError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(DescribeProductError::InvalidParameters(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeProductError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeProductError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeProductError::InvalidParameters(ref cause) => write!(f, "{}", cause),
DescribeProductError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeProductError {}
#[derive(Debug, PartialEq)]
pub enum DescribeProductAsAdminError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl DescribeProductAsAdminError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeProductAsAdminError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(DescribeProductAsAdminError::InvalidParameters(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeProductAsAdminError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeProductAsAdminError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeProductAsAdminError::InvalidParameters(ref cause) => write!(f, "{}", cause),
DescribeProductAsAdminError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeProductAsAdminError {}
#[derive(Debug, PartialEq)]
pub enum DescribeProductViewError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl DescribeProductViewError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeProductViewError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(DescribeProductViewError::InvalidParameters(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeProductViewError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeProductViewError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeProductViewError::InvalidParameters(ref cause) => write!(f, "{}", cause),
DescribeProductViewError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeProductViewError {}
#[derive(Debug, PartialEq)]
pub enum DescribeProvisionedProductError {
ResourceNotFound(String),
}
impl DescribeProvisionedProductError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeProvisionedProductError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeProvisionedProductError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeProvisionedProductError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeProvisionedProductError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeProvisionedProductError {}
#[derive(Debug, PartialEq)]
pub enum DescribeProvisionedProductPlanError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl DescribeProvisionedProductPlanError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeProvisionedProductPlanError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
DescribeProvisionedProductPlanError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeProvisionedProductPlanError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeProvisionedProductPlanError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeProvisionedProductPlanError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
DescribeProvisionedProductPlanError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeProvisionedProductPlanError {}
#[derive(Debug, PartialEq)]
pub enum DescribeProvisioningArtifactError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl DescribeProvisioningArtifactError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeProvisioningArtifactError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
DescribeProvisioningArtifactError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeProvisioningArtifactError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeProvisioningArtifactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeProvisioningArtifactError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
DescribeProvisioningArtifactError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeProvisioningArtifactError {}
#[derive(Debug, PartialEq)]
pub enum DescribeProvisioningParametersError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl DescribeProvisioningParametersError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeProvisioningParametersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
DescribeProvisioningParametersError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeProvisioningParametersError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeProvisioningParametersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeProvisioningParametersError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
DescribeProvisioningParametersError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeProvisioningParametersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeRecordError {
ResourceNotFound(String),
}
impl DescribeRecordError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeRecordError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeRecordError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeRecordError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeRecordError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeRecordError {}
#[derive(Debug, PartialEq)]
pub enum DescribeServiceActionError {
ResourceNotFound(String),
}
impl DescribeServiceActionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeServiceActionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeServiceActionError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeServiceActionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeServiceActionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeServiceActionError {}
#[derive(Debug, PartialEq)]
pub enum DescribeServiceActionExecutionParametersError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl DescribeServiceActionExecutionParametersError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DescribeServiceActionExecutionParametersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
DescribeServiceActionExecutionParametersError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DescribeServiceActionExecutionParametersError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeServiceActionExecutionParametersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeServiceActionExecutionParametersError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
DescribeServiceActionExecutionParametersError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeServiceActionExecutionParametersError {}
#[derive(Debug, PartialEq)]
pub enum DescribeTagOptionError {
ResourceNotFound(String),
TagOptionNotMigrated(String),
}
impl DescribeTagOptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeTagOptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(DescribeTagOptionError::ResourceNotFound(err.msg))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(DescribeTagOptionError::TagOptionNotMigrated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeTagOptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeTagOptionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DescribeTagOptionError::TagOptionNotMigrated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DescribeTagOptionError {}
#[derive(Debug, PartialEq)]
pub enum DisableAWSOrganizationsAccessError {
InvalidState(String),
OperationNotSupported(String),
ResourceNotFound(String),
}
impl DisableAWSOrganizationsAccessError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisableAWSOrganizationsAccessError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidStateException" => {
return RusotoError::Service(DisableAWSOrganizationsAccessError::InvalidState(
err.msg,
))
}
"OperationNotSupportedException" => {
return RusotoError::Service(
DisableAWSOrganizationsAccessError::OperationNotSupported(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DisableAWSOrganizationsAccessError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisableAWSOrganizationsAccessError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisableAWSOrganizationsAccessError::InvalidState(ref cause) => write!(f, "{}", cause),
DisableAWSOrganizationsAccessError::OperationNotSupported(ref cause) => {
write!(f, "{}", cause)
}
DisableAWSOrganizationsAccessError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisableAWSOrganizationsAccessError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateBudgetFromResourceError {
ResourceNotFound(String),
}
impl DisassociateBudgetFromResourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateBudgetFromResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(
DisassociateBudgetFromResourceError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateBudgetFromResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateBudgetFromResourceError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateBudgetFromResourceError {}
#[derive(Debug, PartialEq)]
pub enum DisassociatePrincipalFromPortfolioError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl DisassociatePrincipalFromPortfolioError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociatePrincipalFromPortfolioError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
DisassociatePrincipalFromPortfolioError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DisassociatePrincipalFromPortfolioError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociatePrincipalFromPortfolioError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociatePrincipalFromPortfolioError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
DisassociatePrincipalFromPortfolioError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociatePrincipalFromPortfolioError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateProductFromPortfolioError {
InvalidParameters(String),
ResourceInUse(String),
ResourceNotFound(String),
}
impl DisassociateProductFromPortfolioError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateProductFromPortfolioError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
DisassociateProductFromPortfolioError::InvalidParameters(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(
DisassociateProductFromPortfolioError::ResourceInUse(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DisassociateProductFromPortfolioError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateProductFromPortfolioError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateProductFromPortfolioError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
DisassociateProductFromPortfolioError::ResourceInUse(ref cause) => {
write!(f, "{}", cause)
}
DisassociateProductFromPortfolioError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateProductFromPortfolioError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateServiceActionFromProvisioningArtifactError {
ResourceNotFound(String),
}
impl DisassociateServiceActionFromProvisioningArtifactError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateServiceActionFromProvisioningArtifactError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(
DisassociateServiceActionFromProvisioningArtifactError::ResourceNotFound(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateServiceActionFromProvisioningArtifactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateServiceActionFromProvisioningArtifactError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateServiceActionFromProvisioningArtifactError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateTagOptionFromResourceError {
ResourceNotFound(String),
TagOptionNotMigrated(String),
}
impl DisassociateTagOptionFromResourceError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateTagOptionFromResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(
DisassociateTagOptionFromResourceError::ResourceNotFound(err.msg),
)
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(
DisassociateTagOptionFromResourceError::TagOptionNotMigrated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateTagOptionFromResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateTagOptionFromResourceError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DisassociateTagOptionFromResourceError::TagOptionNotMigrated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DisassociateTagOptionFromResourceError {}
#[derive(Debug, PartialEq)]
pub enum EnableAWSOrganizationsAccessError {
InvalidState(String),
OperationNotSupported(String),
ResourceNotFound(String),
}
impl EnableAWSOrganizationsAccessError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<EnableAWSOrganizationsAccessError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidStateException" => {
return RusotoError::Service(EnableAWSOrganizationsAccessError::InvalidState(
err.msg,
))
}
"OperationNotSupportedException" => {
return RusotoError::Service(
EnableAWSOrganizationsAccessError::OperationNotSupported(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
EnableAWSOrganizationsAccessError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for EnableAWSOrganizationsAccessError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EnableAWSOrganizationsAccessError::InvalidState(ref cause) => write!(f, "{}", cause),
EnableAWSOrganizationsAccessError::OperationNotSupported(ref cause) => {
write!(f, "{}", cause)
}
EnableAWSOrganizationsAccessError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for EnableAWSOrganizationsAccessError {}
#[derive(Debug, PartialEq)]
pub enum ExecuteProvisionedProductPlanError {
InvalidParameters(String),
InvalidState(String),
ResourceNotFound(String),
}
impl ExecuteProvisionedProductPlanError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ExecuteProvisionedProductPlanError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
ExecuteProvisionedProductPlanError::InvalidParameters(err.msg),
)
}
"InvalidStateException" => {
return RusotoError::Service(ExecuteProvisionedProductPlanError::InvalidState(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ExecuteProvisionedProductPlanError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ExecuteProvisionedProductPlanError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ExecuteProvisionedProductPlanError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
ExecuteProvisionedProductPlanError::InvalidState(ref cause) => write!(f, "{}", cause),
ExecuteProvisionedProductPlanError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ExecuteProvisionedProductPlanError {}
#[derive(Debug, PartialEq)]
pub enum ExecuteProvisionedProductServiceActionError {
InvalidParameters(String),
InvalidState(String),
ResourceNotFound(String),
}
impl ExecuteProvisionedProductServiceActionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ExecuteProvisionedProductServiceActionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
ExecuteProvisionedProductServiceActionError::InvalidParameters(err.msg),
)
}
"InvalidStateException" => {
return RusotoError::Service(
ExecuteProvisionedProductServiceActionError::InvalidState(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ExecuteProvisionedProductServiceActionError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ExecuteProvisionedProductServiceActionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ExecuteProvisionedProductServiceActionError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
ExecuteProvisionedProductServiceActionError::InvalidState(ref cause) => {
write!(f, "{}", cause)
}
ExecuteProvisionedProductServiceActionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ExecuteProvisionedProductServiceActionError {}
#[derive(Debug, PartialEq)]
pub enum GetAWSOrganizationsAccessStatusError {
OperationNotSupported(String),
ResourceNotFound(String),
}
impl GetAWSOrganizationsAccessStatusError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetAWSOrganizationsAccessStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"OperationNotSupportedException" => {
return RusotoError::Service(
GetAWSOrganizationsAccessStatusError::OperationNotSupported(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetAWSOrganizationsAccessStatusError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAWSOrganizationsAccessStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAWSOrganizationsAccessStatusError::OperationNotSupported(ref cause) => {
write!(f, "{}", cause)
}
GetAWSOrganizationsAccessStatusError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetAWSOrganizationsAccessStatusError {}
#[derive(Debug, PartialEq)]
pub enum ListAcceptedPortfolioSharesError {
InvalidParameters(String),
OperationNotSupported(String),
}
impl ListAcceptedPortfolioSharesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListAcceptedPortfolioSharesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
ListAcceptedPortfolioSharesError::InvalidParameters(err.msg),
)
}
"OperationNotSupportedException" => {
return RusotoError::Service(
ListAcceptedPortfolioSharesError::OperationNotSupported(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAcceptedPortfolioSharesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAcceptedPortfolioSharesError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
ListAcceptedPortfolioSharesError::OperationNotSupported(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListAcceptedPortfolioSharesError {}
#[derive(Debug, PartialEq)]
pub enum ListBudgetsForResourceError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl ListBudgetsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBudgetsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(ListBudgetsForResourceError::InvalidParameters(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListBudgetsForResourceError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBudgetsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBudgetsForResourceError::InvalidParameters(ref cause) => write!(f, "{}", cause),
ListBudgetsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBudgetsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListConstraintsForPortfolioError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl ListConstraintsForPortfolioError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListConstraintsForPortfolioError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
ListConstraintsForPortfolioError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListConstraintsForPortfolioError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListConstraintsForPortfolioError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListConstraintsForPortfolioError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
ListConstraintsForPortfolioError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListConstraintsForPortfolioError {}
#[derive(Debug, PartialEq)]
pub enum ListLaunchPathsError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl ListLaunchPathsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLaunchPathsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(ListLaunchPathsError::InvalidParameters(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListLaunchPathsError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLaunchPathsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLaunchPathsError::InvalidParameters(ref cause) => write!(f, "{}", cause),
ListLaunchPathsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLaunchPathsError {}
#[derive(Debug, PartialEq)]
pub enum ListOrganizationPortfolioAccessError {
InvalidParameters(String),
OperationNotSupported(String),
ResourceNotFound(String),
}
impl ListOrganizationPortfolioAccessError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListOrganizationPortfolioAccessError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
ListOrganizationPortfolioAccessError::InvalidParameters(err.msg),
)
}
"OperationNotSupportedException" => {
return RusotoError::Service(
ListOrganizationPortfolioAccessError::OperationNotSupported(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListOrganizationPortfolioAccessError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListOrganizationPortfolioAccessError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListOrganizationPortfolioAccessError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
ListOrganizationPortfolioAccessError::OperationNotSupported(ref cause) => {
write!(f, "{}", cause)
}
ListOrganizationPortfolioAccessError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListOrganizationPortfolioAccessError {}
#[derive(Debug, PartialEq)]
pub enum ListPortfolioAccessError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl ListPortfolioAccessError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPortfolioAccessError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(ListPortfolioAccessError::InvalidParameters(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListPortfolioAccessError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPortfolioAccessError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPortfolioAccessError::InvalidParameters(ref cause) => write!(f, "{}", cause),
ListPortfolioAccessError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPortfolioAccessError {}
#[derive(Debug, PartialEq)]
pub enum ListPortfoliosError {
InvalidParameters(String),
}
impl ListPortfoliosError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPortfoliosError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(ListPortfoliosError::InvalidParameters(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPortfoliosError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPortfoliosError::InvalidParameters(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPortfoliosError {}
#[derive(Debug, PartialEq)]
pub enum ListPortfoliosForProductError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl ListPortfoliosForProductError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPortfoliosForProductError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(ListPortfoliosForProductError::InvalidParameters(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListPortfoliosForProductError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPortfoliosForProductError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPortfoliosForProductError::InvalidParameters(ref cause) => write!(f, "{}", cause),
ListPortfoliosForProductError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPortfoliosForProductError {}
#[derive(Debug, PartialEq)]
pub enum ListPrincipalsForPortfolioError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl ListPrincipalsForPortfolioError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListPrincipalsForPortfolioError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
ListPrincipalsForPortfolioError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListPrincipalsForPortfolioError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPrincipalsForPortfolioError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPrincipalsForPortfolioError::InvalidParameters(ref cause) => write!(f, "{}", cause),
ListPrincipalsForPortfolioError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPrincipalsForPortfolioError {}
#[derive(Debug, PartialEq)]
pub enum ListProvisionedProductPlansError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl ListProvisionedProductPlansError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListProvisionedProductPlansError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
ListProvisionedProductPlansError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListProvisionedProductPlansError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListProvisionedProductPlansError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListProvisionedProductPlansError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
ListProvisionedProductPlansError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListProvisionedProductPlansError {}
#[derive(Debug, PartialEq)]
pub enum ListProvisioningArtifactsError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl ListProvisioningArtifactsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListProvisioningArtifactsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(ListProvisioningArtifactsError::InvalidParameters(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListProvisioningArtifactsError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListProvisioningArtifactsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListProvisioningArtifactsError::InvalidParameters(ref cause) => write!(f, "{}", cause),
ListProvisioningArtifactsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListProvisioningArtifactsError {}
#[derive(Debug, PartialEq)]
pub enum ListProvisioningArtifactsForServiceActionError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl ListProvisioningArtifactsForServiceActionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListProvisioningArtifactsForServiceActionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
ListProvisioningArtifactsForServiceActionError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListProvisioningArtifactsForServiceActionError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListProvisioningArtifactsForServiceActionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListProvisioningArtifactsForServiceActionError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
ListProvisioningArtifactsForServiceActionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListProvisioningArtifactsForServiceActionError {}
#[derive(Debug, PartialEq)]
pub enum ListRecordHistoryError {
InvalidParameters(String),
}
impl ListRecordHistoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRecordHistoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(ListRecordHistoryError::InvalidParameters(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRecordHistoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRecordHistoryError::InvalidParameters(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRecordHistoryError {}
#[derive(Debug, PartialEq)]
pub enum ListResourcesForTagOptionError {
InvalidParameters(String),
ResourceNotFound(String),
TagOptionNotMigrated(String),
}
impl ListResourcesForTagOptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListResourcesForTagOptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(ListResourcesForTagOptionError::InvalidParameters(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListResourcesForTagOptionError::ResourceNotFound(
err.msg,
))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(
ListResourcesForTagOptionError::TagOptionNotMigrated(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResourcesForTagOptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResourcesForTagOptionError::InvalidParameters(ref cause) => write!(f, "{}", cause),
ListResourcesForTagOptionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListResourcesForTagOptionError::TagOptionNotMigrated(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListResourcesForTagOptionError {}
#[derive(Debug, PartialEq)]
pub enum ListServiceActionsError {
InvalidParameters(String),
}
impl ListServiceActionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListServiceActionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(ListServiceActionsError::InvalidParameters(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListServiceActionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListServiceActionsError::InvalidParameters(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListServiceActionsError {}
#[derive(Debug, PartialEq)]
pub enum ListServiceActionsForProvisioningArtifactError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl ListServiceActionsForProvisioningArtifactError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListServiceActionsForProvisioningArtifactError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
ListServiceActionsForProvisioningArtifactError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListServiceActionsForProvisioningArtifactError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListServiceActionsForProvisioningArtifactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListServiceActionsForProvisioningArtifactError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
ListServiceActionsForProvisioningArtifactError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListServiceActionsForProvisioningArtifactError {}
#[derive(Debug, PartialEq)]
pub enum ListStackInstancesForProvisionedProductError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl ListStackInstancesForProvisionedProductError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListStackInstancesForProvisionedProductError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
ListStackInstancesForProvisionedProductError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListStackInstancesForProvisionedProductError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListStackInstancesForProvisionedProductError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListStackInstancesForProvisionedProductError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
ListStackInstancesForProvisionedProductError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListStackInstancesForProvisionedProductError {}
#[derive(Debug, PartialEq)]
pub enum ListTagOptionsError {
InvalidParameters(String),
TagOptionNotMigrated(String),
}
impl ListTagOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagOptionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(ListTagOptionsError::InvalidParameters(err.msg))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(ListTagOptionsError::TagOptionNotMigrated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagOptionsError::InvalidParameters(ref cause) => write!(f, "{}", cause),
ListTagOptionsError::TagOptionNotMigrated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagOptionsError {}
#[derive(Debug, PartialEq)]
pub enum ProvisionProductError {
DuplicateResource(String),
InvalidParameters(String),
ResourceNotFound(String),
}
impl ProvisionProductError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ProvisionProductError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DuplicateResourceException" => {
return RusotoError::Service(ProvisionProductError::DuplicateResource(err.msg))
}
"InvalidParametersException" => {
return RusotoError::Service(ProvisionProductError::InvalidParameters(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ProvisionProductError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ProvisionProductError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ProvisionProductError::DuplicateResource(ref cause) => write!(f, "{}", cause),
ProvisionProductError::InvalidParameters(ref cause) => write!(f, "{}", cause),
ProvisionProductError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ProvisionProductError {}
#[derive(Debug, PartialEq)]
pub enum RejectPortfolioShareError {
ResourceNotFound(String),
}
impl RejectPortfolioShareError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RejectPortfolioShareError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(RejectPortfolioShareError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RejectPortfolioShareError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RejectPortfolioShareError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RejectPortfolioShareError {}
#[derive(Debug, PartialEq)]
pub enum ScanProvisionedProductsError {
InvalidParameters(String),
}
impl ScanProvisionedProductsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ScanProvisionedProductsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(ScanProvisionedProductsError::InvalidParameters(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ScanProvisionedProductsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ScanProvisionedProductsError::InvalidParameters(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ScanProvisionedProductsError {}
#[derive(Debug, PartialEq)]
pub enum SearchProductsError {
InvalidParameters(String),
}
impl SearchProductsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SearchProductsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(SearchProductsError::InvalidParameters(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SearchProductsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SearchProductsError::InvalidParameters(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SearchProductsError {}
#[derive(Debug, PartialEq)]
pub enum SearchProductsAsAdminError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl SearchProductsAsAdminError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SearchProductsAsAdminError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(SearchProductsAsAdminError::InvalidParameters(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(SearchProductsAsAdminError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SearchProductsAsAdminError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SearchProductsAsAdminError::InvalidParameters(ref cause) => write!(f, "{}", cause),
SearchProductsAsAdminError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SearchProductsAsAdminError {}
#[derive(Debug, PartialEq)]
pub enum SearchProvisionedProductsError {
InvalidParameters(String),
}
impl SearchProvisionedProductsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<SearchProvisionedProductsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(SearchProvisionedProductsError::InvalidParameters(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for SearchProvisionedProductsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
SearchProvisionedProductsError::InvalidParameters(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for SearchProvisionedProductsError {}
#[derive(Debug, PartialEq)]
pub enum TerminateProvisionedProductError {
ResourceNotFound(String),
}
impl TerminateProvisionedProductError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<TerminateProvisionedProductError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ResourceNotFoundException" => {
return RusotoError::Service(
TerminateProvisionedProductError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TerminateProvisionedProductError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TerminateProvisionedProductError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TerminateProvisionedProductError {}
#[derive(Debug, PartialEq)]
pub enum UpdateConstraintError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl UpdateConstraintError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateConstraintError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(UpdateConstraintError::InvalidParameters(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateConstraintError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateConstraintError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateConstraintError::InvalidParameters(ref cause) => write!(f, "{}", cause),
UpdateConstraintError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateConstraintError {}
#[derive(Debug, PartialEq)]
pub enum UpdatePortfolioError {
InvalidParameters(String),
LimitExceeded(String),
ResourceNotFound(String),
TagOptionNotMigrated(String),
}
impl UpdatePortfolioError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdatePortfolioError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(UpdatePortfolioError::InvalidParameters(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdatePortfolioError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdatePortfolioError::ResourceNotFound(err.msg))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(UpdatePortfolioError::TagOptionNotMigrated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdatePortfolioError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdatePortfolioError::InvalidParameters(ref cause) => write!(f, "{}", cause),
UpdatePortfolioError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdatePortfolioError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdatePortfolioError::TagOptionNotMigrated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdatePortfolioError {}
#[derive(Debug, PartialEq)]
pub enum UpdateProductError {
InvalidParameters(String),
ResourceNotFound(String),
TagOptionNotMigrated(String),
}
impl UpdateProductError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateProductError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(UpdateProductError::InvalidParameters(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateProductError::ResourceNotFound(err.msg))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(UpdateProductError::TagOptionNotMigrated(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateProductError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateProductError::InvalidParameters(ref cause) => write!(f, "{}", cause),
UpdateProductError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateProductError::TagOptionNotMigrated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateProductError {}
#[derive(Debug, PartialEq)]
pub enum UpdateProvisionedProductError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl UpdateProvisionedProductError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateProvisionedProductError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(UpdateProvisionedProductError::InvalidParameters(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateProvisionedProductError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateProvisionedProductError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateProvisionedProductError::InvalidParameters(ref cause) => write!(f, "{}", cause),
UpdateProvisionedProductError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateProvisionedProductError {}
#[derive(Debug, PartialEq)]
pub enum UpdateProvisionedProductPropertiesError {
InvalidParameters(String),
InvalidState(String),
ResourceNotFound(String),
}
impl UpdateProvisionedProductPropertiesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateProvisionedProductPropertiesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
UpdateProvisionedProductPropertiesError::InvalidParameters(err.msg),
)
}
"InvalidStateException" => {
return RusotoError::Service(
UpdateProvisionedProductPropertiesError::InvalidState(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
UpdateProvisionedProductPropertiesError::ResourceNotFound(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateProvisionedProductPropertiesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateProvisionedProductPropertiesError::InvalidParameters(ref cause) => {
write!(f, "{}", cause)
}
UpdateProvisionedProductPropertiesError::InvalidState(ref cause) => {
write!(f, "{}", cause)
}
UpdateProvisionedProductPropertiesError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateProvisionedProductPropertiesError {}
#[derive(Debug, PartialEq)]
pub enum UpdateProvisioningArtifactError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl UpdateProvisioningArtifactError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateProvisioningArtifactError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(
UpdateProvisioningArtifactError::InvalidParameters(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateProvisioningArtifactError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateProvisioningArtifactError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateProvisioningArtifactError::InvalidParameters(ref cause) => write!(f, "{}", cause),
UpdateProvisioningArtifactError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateProvisioningArtifactError {}
#[derive(Debug, PartialEq)]
pub enum UpdateServiceActionError {
InvalidParameters(String),
ResourceNotFound(String),
}
impl UpdateServiceActionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateServiceActionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidParametersException" => {
return RusotoError::Service(UpdateServiceActionError::InvalidParameters(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateServiceActionError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateServiceActionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateServiceActionError::InvalidParameters(ref cause) => write!(f, "{}", cause),
UpdateServiceActionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateServiceActionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateTagOptionError {
DuplicateResource(String),
InvalidParameters(String),
ResourceNotFound(String),
TagOptionNotMigrated(String),
}
impl UpdateTagOptionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateTagOptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"DuplicateResourceException" => {
return RusotoError::Service(UpdateTagOptionError::DuplicateResource(err.msg))
}
"InvalidParametersException" => {
return RusotoError::Service(UpdateTagOptionError::InvalidParameters(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateTagOptionError::ResourceNotFound(err.msg))
}
"TagOptionNotMigratedException" => {
return RusotoError::Service(UpdateTagOptionError::TagOptionNotMigrated(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateTagOptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateTagOptionError::DuplicateResource(ref cause) => write!(f, "{}", cause),
UpdateTagOptionError::InvalidParameters(ref cause) => write!(f, "{}", cause),
UpdateTagOptionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateTagOptionError::TagOptionNotMigrated(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateTagOptionError {}
#[async_trait]
pub trait ServiceCatalog {
async fn accept_portfolio_share(
&self,
input: AcceptPortfolioShareInput,
) -> Result<AcceptPortfolioShareOutput, RusotoError<AcceptPortfolioShareError>>;
async fn associate_budget_with_resource(
&self,
input: AssociateBudgetWithResourceInput,
) -> Result<AssociateBudgetWithResourceOutput, RusotoError<AssociateBudgetWithResourceError>>;
async fn associate_principal_with_portfolio(
&self,
input: AssociatePrincipalWithPortfolioInput,
) -> Result<
AssociatePrincipalWithPortfolioOutput,
RusotoError<AssociatePrincipalWithPortfolioError>,
>;
async fn associate_product_with_portfolio(
&self,
input: AssociateProductWithPortfolioInput,
) -> Result<AssociateProductWithPortfolioOutput, RusotoError<AssociateProductWithPortfolioError>>;
async fn associate_service_action_with_provisioning_artifact(
&self,
input: AssociateServiceActionWithProvisioningArtifactInput,
) -> Result<
AssociateServiceActionWithProvisioningArtifactOutput,
RusotoError<AssociateServiceActionWithProvisioningArtifactError>,
>;
async fn associate_tag_option_with_resource(
&self,
input: AssociateTagOptionWithResourceInput,
) -> Result<
AssociateTagOptionWithResourceOutput,
RusotoError<AssociateTagOptionWithResourceError>,
>;
async fn batch_associate_service_action_with_provisioning_artifact(
&self,
input: BatchAssociateServiceActionWithProvisioningArtifactInput,
) -> Result<
BatchAssociateServiceActionWithProvisioningArtifactOutput,
RusotoError<BatchAssociateServiceActionWithProvisioningArtifactError>,
>;
async fn batch_disassociate_service_action_from_provisioning_artifact(
&self,
input: BatchDisassociateServiceActionFromProvisioningArtifactInput,
) -> Result<
BatchDisassociateServiceActionFromProvisioningArtifactOutput,
RusotoError<BatchDisassociateServiceActionFromProvisioningArtifactError>,
>;
async fn copy_product(
&self,
input: CopyProductInput,
) -> Result<CopyProductOutput, RusotoError<CopyProductError>>;
async fn create_constraint(
&self,
input: CreateConstraintInput,
) -> Result<CreateConstraintOutput, RusotoError<CreateConstraintError>>;
async fn create_portfolio(
&self,
input: CreatePortfolioInput,
) -> Result<CreatePortfolioOutput, RusotoError<CreatePortfolioError>>;
async fn create_portfolio_share(
&self,
input: CreatePortfolioShareInput,
) -> Result<CreatePortfolioShareOutput, RusotoError<CreatePortfolioShareError>>;
async fn create_product(
&self,
input: CreateProductInput,
) -> Result<CreateProductOutput, RusotoError<CreateProductError>>;
async fn create_provisioned_product_plan(
&self,
input: CreateProvisionedProductPlanInput,
) -> Result<CreateProvisionedProductPlanOutput, RusotoError<CreateProvisionedProductPlanError>>;
async fn create_provisioning_artifact(
&self,
input: CreateProvisioningArtifactInput,
) -> Result<CreateProvisioningArtifactOutput, RusotoError<CreateProvisioningArtifactError>>;
async fn create_service_action(
&self,
input: CreateServiceActionInput,
) -> Result<CreateServiceActionOutput, RusotoError<CreateServiceActionError>>;
async fn create_tag_option(
&self,
input: CreateTagOptionInput,
) -> Result<CreateTagOptionOutput, RusotoError<CreateTagOptionError>>;
async fn delete_constraint(
&self,
input: DeleteConstraintInput,
) -> Result<DeleteConstraintOutput, RusotoError<DeleteConstraintError>>;
async fn delete_portfolio(
&self,
input: DeletePortfolioInput,
) -> Result<DeletePortfolioOutput, RusotoError<DeletePortfolioError>>;
async fn delete_portfolio_share(
&self,
input: DeletePortfolioShareInput,
) -> Result<DeletePortfolioShareOutput, RusotoError<DeletePortfolioShareError>>;
async fn delete_product(
&self,
input: DeleteProductInput,
) -> Result<DeleteProductOutput, RusotoError<DeleteProductError>>;
async fn delete_provisioned_product_plan(
&self,
input: DeleteProvisionedProductPlanInput,
) -> Result<DeleteProvisionedProductPlanOutput, RusotoError<DeleteProvisionedProductPlanError>>;
async fn delete_provisioning_artifact(
&self,
input: DeleteProvisioningArtifactInput,
) -> Result<DeleteProvisioningArtifactOutput, RusotoError<DeleteProvisioningArtifactError>>;
async fn delete_service_action(
&self,
input: DeleteServiceActionInput,
) -> Result<DeleteServiceActionOutput, RusotoError<DeleteServiceActionError>>;
async fn delete_tag_option(
&self,
input: DeleteTagOptionInput,
) -> Result<DeleteTagOptionOutput, RusotoError<DeleteTagOptionError>>;
async fn describe_constraint(
&self,
input: DescribeConstraintInput,
) -> Result<DescribeConstraintOutput, RusotoError<DescribeConstraintError>>;
async fn describe_copy_product_status(
&self,
input: DescribeCopyProductStatusInput,
) -> Result<DescribeCopyProductStatusOutput, RusotoError<DescribeCopyProductStatusError>>;
async fn describe_portfolio(
&self,
input: DescribePortfolioInput,
) -> Result<DescribePortfolioOutput, RusotoError<DescribePortfolioError>>;
async fn describe_portfolio_share_status(
&self,
input: DescribePortfolioShareStatusInput,
) -> Result<DescribePortfolioShareStatusOutput, RusotoError<DescribePortfolioShareStatusError>>;
async fn describe_product(
&self,
input: DescribeProductInput,
) -> Result<DescribeProductOutput, RusotoError<DescribeProductError>>;
async fn describe_product_as_admin(
&self,
input: DescribeProductAsAdminInput,
) -> Result<DescribeProductAsAdminOutput, RusotoError<DescribeProductAsAdminError>>;
async fn describe_product_view(
&self,
input: DescribeProductViewInput,
) -> Result<DescribeProductViewOutput, RusotoError<DescribeProductViewError>>;
async fn describe_provisioned_product(
&self,
input: DescribeProvisionedProductInput,
) -> Result<DescribeProvisionedProductOutput, RusotoError<DescribeProvisionedProductError>>;
async fn describe_provisioned_product_plan(
&self,
input: DescribeProvisionedProductPlanInput,
) -> Result<
DescribeProvisionedProductPlanOutput,
RusotoError<DescribeProvisionedProductPlanError>,
>;
async fn describe_provisioning_artifact(
&self,
input: DescribeProvisioningArtifactInput,
) -> Result<DescribeProvisioningArtifactOutput, RusotoError<DescribeProvisioningArtifactError>>;
async fn describe_provisioning_parameters(
&self,
input: DescribeProvisioningParametersInput,
) -> Result<
DescribeProvisioningParametersOutput,
RusotoError<DescribeProvisioningParametersError>,
>;
async fn describe_record(
&self,
input: DescribeRecordInput,
) -> Result<DescribeRecordOutput, RusotoError<DescribeRecordError>>;
async fn describe_service_action(
&self,
input: DescribeServiceActionInput,
) -> Result<DescribeServiceActionOutput, RusotoError<DescribeServiceActionError>>;
async fn describe_service_action_execution_parameters(
&self,
input: DescribeServiceActionExecutionParametersInput,
) -> Result<
DescribeServiceActionExecutionParametersOutput,
RusotoError<DescribeServiceActionExecutionParametersError>,
>;
async fn describe_tag_option(
&self,
input: DescribeTagOptionInput,
) -> Result<DescribeTagOptionOutput, RusotoError<DescribeTagOptionError>>;
async fn disable_aws_organizations_access(
&self,
) -> Result<DisableAWSOrganizationsAccessOutput, RusotoError<DisableAWSOrganizationsAccessError>>;
async fn disassociate_budget_from_resource(
&self,
input: DisassociateBudgetFromResourceInput,
) -> Result<
DisassociateBudgetFromResourceOutput,
RusotoError<DisassociateBudgetFromResourceError>,
>;
async fn disassociate_principal_from_portfolio(
&self,
input: DisassociatePrincipalFromPortfolioInput,
) -> Result<
DisassociatePrincipalFromPortfolioOutput,
RusotoError<DisassociatePrincipalFromPortfolioError>,
>;
async fn disassociate_product_from_portfolio(
&self,
input: DisassociateProductFromPortfolioInput,
) -> Result<
DisassociateProductFromPortfolioOutput,
RusotoError<DisassociateProductFromPortfolioError>,
>;
async fn disassociate_service_action_from_provisioning_artifact(
&self,
input: DisassociateServiceActionFromProvisioningArtifactInput,
) -> Result<
DisassociateServiceActionFromProvisioningArtifactOutput,
RusotoError<DisassociateServiceActionFromProvisioningArtifactError>,
>;
async fn disassociate_tag_option_from_resource(
&self,
input: DisassociateTagOptionFromResourceInput,
) -> Result<
DisassociateTagOptionFromResourceOutput,
RusotoError<DisassociateTagOptionFromResourceError>,
>;
async fn enable_aws_organizations_access(
&self,
) -> Result<EnableAWSOrganizationsAccessOutput, RusotoError<EnableAWSOrganizationsAccessError>>;
async fn execute_provisioned_product_plan(
&self,
input: ExecuteProvisionedProductPlanInput,
) -> Result<ExecuteProvisionedProductPlanOutput, RusotoError<ExecuteProvisionedProductPlanError>>;
async fn execute_provisioned_product_service_action(
&self,
input: ExecuteProvisionedProductServiceActionInput,
) -> Result<
ExecuteProvisionedProductServiceActionOutput,
RusotoError<ExecuteProvisionedProductServiceActionError>,
>;
async fn get_aws_organizations_access_status(
&self,
) -> Result<
GetAWSOrganizationsAccessStatusOutput,
RusotoError<GetAWSOrganizationsAccessStatusError>,
>;
async fn list_accepted_portfolio_shares(
&self,
input: ListAcceptedPortfolioSharesInput,
) -> Result<ListAcceptedPortfolioSharesOutput, RusotoError<ListAcceptedPortfolioSharesError>>;
async fn list_budgets_for_resource(
&self,
input: ListBudgetsForResourceInput,
) -> Result<ListBudgetsForResourceOutput, RusotoError<ListBudgetsForResourceError>>;
async fn list_constraints_for_portfolio(
&self,
input: ListConstraintsForPortfolioInput,
) -> Result<ListConstraintsForPortfolioOutput, RusotoError<ListConstraintsForPortfolioError>>;
async fn list_launch_paths(
&self,
input: ListLaunchPathsInput,
) -> Result<ListLaunchPathsOutput, RusotoError<ListLaunchPathsError>>;
async fn list_organization_portfolio_access(
&self,
input: ListOrganizationPortfolioAccessInput,
) -> Result<
ListOrganizationPortfolioAccessOutput,
RusotoError<ListOrganizationPortfolioAccessError>,
>;
async fn list_portfolio_access(
&self,
input: ListPortfolioAccessInput,
) -> Result<ListPortfolioAccessOutput, RusotoError<ListPortfolioAccessError>>;
async fn list_portfolios(
&self,
input: ListPortfoliosInput,
) -> Result<ListPortfoliosOutput, RusotoError<ListPortfoliosError>>;
async fn list_portfolios_for_product(
&self,
input: ListPortfoliosForProductInput,
) -> Result<ListPortfoliosForProductOutput, RusotoError<ListPortfoliosForProductError>>;
async fn list_principals_for_portfolio(
&self,
input: ListPrincipalsForPortfolioInput,
) -> Result<ListPrincipalsForPortfolioOutput, RusotoError<ListPrincipalsForPortfolioError>>;
async fn list_provisioned_product_plans(
&self,
input: ListProvisionedProductPlansInput,
) -> Result<ListProvisionedProductPlansOutput, RusotoError<ListProvisionedProductPlansError>>;
async fn list_provisioning_artifacts(
&self,
input: ListProvisioningArtifactsInput,
) -> Result<ListProvisioningArtifactsOutput, RusotoError<ListProvisioningArtifactsError>>;
async fn list_provisioning_artifacts_for_service_action(
&self,
input: ListProvisioningArtifactsForServiceActionInput,
) -> Result<
ListProvisioningArtifactsForServiceActionOutput,
RusotoError<ListProvisioningArtifactsForServiceActionError>,
>;
async fn list_record_history(
&self,
input: ListRecordHistoryInput,
) -> Result<ListRecordHistoryOutput, RusotoError<ListRecordHistoryError>>;
async fn list_resources_for_tag_option(
&self,
input: ListResourcesForTagOptionInput,
) -> Result<ListResourcesForTagOptionOutput, RusotoError<ListResourcesForTagOptionError>>;
async fn list_service_actions(
&self,
input: ListServiceActionsInput,
) -> Result<ListServiceActionsOutput, RusotoError<ListServiceActionsError>>;
async fn list_service_actions_for_provisioning_artifact(
&self,
input: ListServiceActionsForProvisioningArtifactInput,
) -> Result<
ListServiceActionsForProvisioningArtifactOutput,
RusotoError<ListServiceActionsForProvisioningArtifactError>,
>;
async fn list_stack_instances_for_provisioned_product(
&self,
input: ListStackInstancesForProvisionedProductInput,
) -> Result<
ListStackInstancesForProvisionedProductOutput,
RusotoError<ListStackInstancesForProvisionedProductError>,
>;
async fn list_tag_options(
&self,
input: ListTagOptionsInput,
) -> Result<ListTagOptionsOutput, RusotoError<ListTagOptionsError>>;
async fn provision_product(
&self,
input: ProvisionProductInput,
) -> Result<ProvisionProductOutput, RusotoError<ProvisionProductError>>;
async fn reject_portfolio_share(
&self,
input: RejectPortfolioShareInput,
) -> Result<RejectPortfolioShareOutput, RusotoError<RejectPortfolioShareError>>;
async fn scan_provisioned_products(
&self,
input: ScanProvisionedProductsInput,
) -> Result<ScanProvisionedProductsOutput, RusotoError<ScanProvisionedProductsError>>;
async fn search_products(
&self,
input: SearchProductsInput,
) -> Result<SearchProductsOutput, RusotoError<SearchProductsError>>;
async fn search_products_as_admin(
&self,
input: SearchProductsAsAdminInput,
) -> Result<SearchProductsAsAdminOutput, RusotoError<SearchProductsAsAdminError>>;
async fn search_provisioned_products(
&self,
input: SearchProvisionedProductsInput,
) -> Result<SearchProvisionedProductsOutput, RusotoError<SearchProvisionedProductsError>>;
async fn terminate_provisioned_product(
&self,
input: TerminateProvisionedProductInput,
) -> Result<TerminateProvisionedProductOutput, RusotoError<TerminateProvisionedProductError>>;
async fn update_constraint(
&self,
input: UpdateConstraintInput,
) -> Result<UpdateConstraintOutput, RusotoError<UpdateConstraintError>>;
async fn update_portfolio(
&self,
input: UpdatePortfolioInput,
) -> Result<UpdatePortfolioOutput, RusotoError<UpdatePortfolioError>>;
async fn update_product(
&self,
input: UpdateProductInput,
) -> Result<UpdateProductOutput, RusotoError<UpdateProductError>>;
async fn update_provisioned_product(
&self,
input: UpdateProvisionedProductInput,
) -> Result<UpdateProvisionedProductOutput, RusotoError<UpdateProvisionedProductError>>;
async fn update_provisioned_product_properties(
&self,
input: UpdateProvisionedProductPropertiesInput,
) -> Result<
UpdateProvisionedProductPropertiesOutput,
RusotoError<UpdateProvisionedProductPropertiesError>,
>;
async fn update_provisioning_artifact(
&self,
input: UpdateProvisioningArtifactInput,
) -> Result<UpdateProvisioningArtifactOutput, RusotoError<UpdateProvisioningArtifactError>>;
async fn update_service_action(
&self,
input: UpdateServiceActionInput,
) -> Result<UpdateServiceActionOutput, RusotoError<UpdateServiceActionError>>;
async fn update_tag_option(
&self,
input: UpdateTagOptionInput,
) -> Result<UpdateTagOptionOutput, RusotoError<UpdateTagOptionError>>;
}
#[derive(Clone)]
pub struct ServiceCatalogClient {
client: Client,
region: region::Region,
}
impl ServiceCatalogClient {
pub fn new(region: region::Region) -> ServiceCatalogClient {
ServiceCatalogClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ServiceCatalogClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ServiceCatalogClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ServiceCatalogClient {
ServiceCatalogClient { client, region }
}
}
#[async_trait]
impl ServiceCatalog for ServiceCatalogClient {
async fn accept_portfolio_share(
&self,
input: AcceptPortfolioShareInput,
) -> Result<AcceptPortfolioShareOutput, RusotoError<AcceptPortfolioShareError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.AcceptPortfolioShare",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AcceptPortfolioShareError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<AcceptPortfolioShareOutput, _>()
}
async fn associate_budget_with_resource(
&self,
input: AssociateBudgetWithResourceInput,
) -> Result<AssociateBudgetWithResourceOutput, RusotoError<AssociateBudgetWithResourceError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.AssociateBudgetWithResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociateBudgetWithResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateBudgetWithResourceOutput, _>()
}
async fn associate_principal_with_portfolio(
&self,
input: AssociatePrincipalWithPortfolioInput,
) -> Result<
AssociatePrincipalWithPortfolioOutput,
RusotoError<AssociatePrincipalWithPortfolioError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.AssociatePrincipalWithPortfolio",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociatePrincipalWithPortfolioError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociatePrincipalWithPortfolioOutput, _>()
}
async fn associate_product_with_portfolio(
&self,
input: AssociateProductWithPortfolioInput,
) -> Result<AssociateProductWithPortfolioOutput, RusotoError<AssociateProductWithPortfolioError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.AssociateProductWithPortfolio",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociateProductWithPortfolioError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateProductWithPortfolioOutput, _>()
}
async fn associate_service_action_with_provisioning_artifact(
&self,
input: AssociateServiceActionWithProvisioningArtifactInput,
) -> Result<
AssociateServiceActionWithProvisioningArtifactOutput,
RusotoError<AssociateServiceActionWithProvisioningArtifactError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.AssociateServiceActionWithProvisioningArtifact",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
AssociateServiceActionWithProvisioningArtifactError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateServiceActionWithProvisioningArtifactOutput, _>()
}
async fn associate_tag_option_with_resource(
&self,
input: AssociateTagOptionWithResourceInput,
) -> Result<
AssociateTagOptionWithResourceOutput,
RusotoError<AssociateTagOptionWithResourceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.AssociateTagOptionWithResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, AssociateTagOptionWithResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<AssociateTagOptionWithResourceOutput, _>()
}
async fn batch_associate_service_action_with_provisioning_artifact(
&self,
input: BatchAssociateServiceActionWithProvisioningArtifactInput,
) -> Result<
BatchAssociateServiceActionWithProvisioningArtifactOutput,
RusotoError<BatchAssociateServiceActionWithProvisioningArtifactError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.BatchAssociateServiceActionWithProvisioningArtifact",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
BatchAssociateServiceActionWithProvisioningArtifactError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchAssociateServiceActionWithProvisioningArtifactOutput, _>()
}
async fn batch_disassociate_service_action_from_provisioning_artifact(
&self,
input: BatchDisassociateServiceActionFromProvisioningArtifactInput,
) -> Result<
BatchDisassociateServiceActionFromProvisioningArtifactOutput,
RusotoError<BatchDisassociateServiceActionFromProvisioningArtifactError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.BatchDisassociateServiceActionFromProvisioningArtifact",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
BatchDisassociateServiceActionFromProvisioningArtifactError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchDisassociateServiceActionFromProvisioningArtifactOutput, _>()
}
async fn copy_product(
&self,
input: CopyProductInput,
) -> Result<CopyProductOutput, RusotoError<CopyProductError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWS242ServiceCatalogService.CopyProduct");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CopyProductError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CopyProductOutput, _>()
}
async fn create_constraint(
&self,
input: CreateConstraintInput,
) -> Result<CreateConstraintOutput, RusotoError<CreateConstraintError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.CreateConstraint",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateConstraintError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateConstraintOutput, _>()
}
async fn create_portfolio(
&self,
input: CreatePortfolioInput,
) -> Result<CreatePortfolioOutput, RusotoError<CreatePortfolioError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.CreatePortfolio",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreatePortfolioError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreatePortfolioOutput, _>()
}
async fn create_portfolio_share(
&self,
input: CreatePortfolioShareInput,
) -> Result<CreatePortfolioShareOutput, RusotoError<CreatePortfolioShareError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.CreatePortfolioShare",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreatePortfolioShareError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreatePortfolioShareOutput, _>()
}
async fn create_product(
&self,
input: CreateProductInput,
) -> Result<CreateProductOutput, RusotoError<CreateProductError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWS242ServiceCatalogService.CreateProduct");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateProductError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateProductOutput, _>()
}
async fn create_provisioned_product_plan(
&self,
input: CreateProvisionedProductPlanInput,
) -> Result<CreateProvisionedProductPlanOutput, RusotoError<CreateProvisionedProductPlanError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.CreateProvisionedProductPlan",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateProvisionedProductPlanError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateProvisionedProductPlanOutput, _>()
}
async fn create_provisioning_artifact(
&self,
input: CreateProvisioningArtifactInput,
) -> Result<CreateProvisioningArtifactOutput, RusotoError<CreateProvisioningArtifactError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.CreateProvisioningArtifact",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateProvisioningArtifactError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateProvisioningArtifactOutput, _>()
}
async fn create_service_action(
&self,
input: CreateServiceActionInput,
) -> Result<CreateServiceActionOutput, RusotoError<CreateServiceActionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.CreateServiceAction",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateServiceActionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateServiceActionOutput, _>()
}
async fn create_tag_option(
&self,
input: CreateTagOptionInput,
) -> Result<CreateTagOptionOutput, RusotoError<CreateTagOptionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.CreateTagOption",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateTagOptionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateTagOptionOutput, _>()
}
async fn delete_constraint(
&self,
input: DeleteConstraintInput,
) -> Result<DeleteConstraintOutput, RusotoError<DeleteConstraintError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DeleteConstraint",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteConstraintError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteConstraintOutput, _>()
}
async fn delete_portfolio(
&self,
input: DeletePortfolioInput,
) -> Result<DeletePortfolioOutput, RusotoError<DeletePortfolioError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DeletePortfolio",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeletePortfolioError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeletePortfolioOutput, _>()
}
async fn delete_portfolio_share(
&self,
input: DeletePortfolioShareInput,
) -> Result<DeletePortfolioShareOutput, RusotoError<DeletePortfolioShareError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DeletePortfolioShare",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeletePortfolioShareError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeletePortfolioShareOutput, _>()
}
async fn delete_product(
&self,
input: DeleteProductInput,
) -> Result<DeleteProductOutput, RusotoError<DeleteProductError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWS242ServiceCatalogService.DeleteProduct");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteProductError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteProductOutput, _>()
}
async fn delete_provisioned_product_plan(
&self,
input: DeleteProvisionedProductPlanInput,
) -> Result<DeleteProvisionedProductPlanOutput, RusotoError<DeleteProvisionedProductPlanError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DeleteProvisionedProductPlan",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteProvisionedProductPlanError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteProvisionedProductPlanOutput, _>()
}
async fn delete_provisioning_artifact(
&self,
input: DeleteProvisioningArtifactInput,
) -> Result<DeleteProvisioningArtifactOutput, RusotoError<DeleteProvisioningArtifactError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DeleteProvisioningArtifact",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteProvisioningArtifactError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteProvisioningArtifactOutput, _>()
}
async fn delete_service_action(
&self,
input: DeleteServiceActionInput,
) -> Result<DeleteServiceActionOutput, RusotoError<DeleteServiceActionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DeleteServiceAction",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteServiceActionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteServiceActionOutput, _>()
}
async fn delete_tag_option(
&self,
input: DeleteTagOptionInput,
) -> Result<DeleteTagOptionOutput, RusotoError<DeleteTagOptionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DeleteTagOption",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteTagOptionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteTagOptionOutput, _>()
}
async fn describe_constraint(
&self,
input: DescribeConstraintInput,
) -> Result<DescribeConstraintOutput, RusotoError<DescribeConstraintError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeConstraint",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeConstraintError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeConstraintOutput, _>()
}
async fn describe_copy_product_status(
&self,
input: DescribeCopyProductStatusInput,
) -> Result<DescribeCopyProductStatusOutput, RusotoError<DescribeCopyProductStatusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeCopyProductStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeCopyProductStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeCopyProductStatusOutput, _>()
}
async fn describe_portfolio(
&self,
input: DescribePortfolioInput,
) -> Result<DescribePortfolioOutput, RusotoError<DescribePortfolioError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribePortfolio",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribePortfolioError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribePortfolioOutput, _>()
}
async fn describe_portfolio_share_status(
&self,
input: DescribePortfolioShareStatusInput,
) -> Result<DescribePortfolioShareStatusOutput, RusotoError<DescribePortfolioShareStatusError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribePortfolioShareStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribePortfolioShareStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribePortfolioShareStatusOutput, _>()
}
async fn describe_product(
&self,
input: DescribeProductInput,
) -> Result<DescribeProductOutput, RusotoError<DescribeProductError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeProduct",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeProductError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeProductOutput, _>()
}
async fn describe_product_as_admin(
&self,
input: DescribeProductAsAdminInput,
) -> Result<DescribeProductAsAdminOutput, RusotoError<DescribeProductAsAdminError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeProductAsAdmin",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeProductAsAdminError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeProductAsAdminOutput, _>()
}
async fn describe_product_view(
&self,
input: DescribeProductViewInput,
) -> Result<DescribeProductViewOutput, RusotoError<DescribeProductViewError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeProductView",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeProductViewError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeProductViewOutput, _>()
}
async fn describe_provisioned_product(
&self,
input: DescribeProvisionedProductInput,
) -> Result<DescribeProvisionedProductOutput, RusotoError<DescribeProvisionedProductError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeProvisionedProduct",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeProvisionedProductError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeProvisionedProductOutput, _>()
}
async fn describe_provisioned_product_plan(
&self,
input: DescribeProvisionedProductPlanInput,
) -> Result<
DescribeProvisionedProductPlanOutput,
RusotoError<DescribeProvisionedProductPlanError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeProvisionedProductPlan",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeProvisionedProductPlanError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeProvisionedProductPlanOutput, _>()
}
async fn describe_provisioning_artifact(
&self,
input: DescribeProvisioningArtifactInput,
) -> Result<DescribeProvisioningArtifactOutput, RusotoError<DescribeProvisioningArtifactError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeProvisioningArtifact",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeProvisioningArtifactError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeProvisioningArtifactOutput, _>()
}
async fn describe_provisioning_parameters(
&self,
input: DescribeProvisioningParametersInput,
) -> Result<
DescribeProvisioningParametersOutput,
RusotoError<DescribeProvisioningParametersError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeProvisioningParameters",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeProvisioningParametersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeProvisioningParametersOutput, _>()
}
async fn describe_record(
&self,
input: DescribeRecordInput,
) -> Result<DescribeRecordOutput, RusotoError<DescribeRecordError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWS242ServiceCatalogService.DescribeRecord");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeRecordError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeRecordOutput, _>()
}
async fn describe_service_action(
&self,
input: DescribeServiceActionInput,
) -> Result<DescribeServiceActionOutput, RusotoError<DescribeServiceActionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeServiceAction",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeServiceActionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeServiceActionOutput, _>()
}
async fn describe_service_action_execution_parameters(
&self,
input: DescribeServiceActionExecutionParametersInput,
) -> Result<
DescribeServiceActionExecutionParametersOutput,
RusotoError<DescribeServiceActionExecutionParametersError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeServiceActionExecutionParameters",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DescribeServiceActionExecutionParametersError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeServiceActionExecutionParametersOutput, _>()
}
async fn describe_tag_option(
&self,
input: DescribeTagOptionInput,
) -> Result<DescribeTagOptionOutput, RusotoError<DescribeTagOptionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DescribeTagOption",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeTagOptionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DescribeTagOptionOutput, _>()
}
async fn disable_aws_organizations_access(
&self,
) -> Result<DisableAWSOrganizationsAccessOutput, RusotoError<DisableAWSOrganizationsAccessError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DisableAWSOrganizationsAccess",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, DisableAWSOrganizationsAccessError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisableAWSOrganizationsAccessOutput, _>()
}
async fn disassociate_budget_from_resource(
&self,
input: DisassociateBudgetFromResourceInput,
) -> Result<
DisassociateBudgetFromResourceOutput,
RusotoError<DisassociateBudgetFromResourceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DisassociateBudgetFromResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DisassociateBudgetFromResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateBudgetFromResourceOutput, _>()
}
async fn disassociate_principal_from_portfolio(
&self,
input: DisassociatePrincipalFromPortfolioInput,
) -> Result<
DisassociatePrincipalFromPortfolioOutput,
RusotoError<DisassociatePrincipalFromPortfolioError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DisassociatePrincipalFromPortfolio",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DisassociatePrincipalFromPortfolioError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociatePrincipalFromPortfolioOutput, _>()
}
async fn disassociate_product_from_portfolio(
&self,
input: DisassociateProductFromPortfolioInput,
) -> Result<
DisassociateProductFromPortfolioOutput,
RusotoError<DisassociateProductFromPortfolioError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DisassociateProductFromPortfolio",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DisassociateProductFromPortfolioError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateProductFromPortfolioOutput, _>()
}
async fn disassociate_service_action_from_provisioning_artifact(
&self,
input: DisassociateServiceActionFromProvisioningArtifactInput,
) -> Result<
DisassociateServiceActionFromProvisioningArtifactOutput,
RusotoError<DisassociateServiceActionFromProvisioningArtifactError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DisassociateServiceActionFromProvisioningArtifact",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DisassociateServiceActionFromProvisioningArtifactError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateServiceActionFromProvisioningArtifactOutput, _>()
}
async fn disassociate_tag_option_from_resource(
&self,
input: DisassociateTagOptionFromResourceInput,
) -> Result<
DisassociateTagOptionFromResourceOutput,
RusotoError<DisassociateTagOptionFromResourceError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.DisassociateTagOptionFromResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DisassociateTagOptionFromResourceError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DisassociateTagOptionFromResourceOutput, _>()
}
async fn enable_aws_organizations_access(
&self,
) -> Result<EnableAWSOrganizationsAccessOutput, RusotoError<EnableAWSOrganizationsAccessError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.EnableAWSOrganizationsAccess",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, EnableAWSOrganizationsAccessError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<EnableAWSOrganizationsAccessOutput, _>()
}
async fn execute_provisioned_product_plan(
&self,
input: ExecuteProvisionedProductPlanInput,
) -> Result<ExecuteProvisionedProductPlanOutput, RusotoError<ExecuteProvisionedProductPlanError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ExecuteProvisionedProductPlan",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ExecuteProvisionedProductPlanError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ExecuteProvisionedProductPlanOutput, _>()
}
async fn execute_provisioned_product_service_action(
&self,
input: ExecuteProvisionedProductServiceActionInput,
) -> Result<
ExecuteProvisionedProductServiceActionOutput,
RusotoError<ExecuteProvisionedProductServiceActionError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ExecuteProvisionedProductServiceAction",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ExecuteProvisionedProductServiceActionError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ExecuteProvisionedProductServiceActionOutput, _>()
}
async fn get_aws_organizations_access_status(
&self,
) -> Result<
GetAWSOrganizationsAccessStatusOutput,
RusotoError<GetAWSOrganizationsAccessStatusError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.GetAWSOrganizationsAccessStatus",
);
request.set_payload(Some(bytes::Bytes::from_static(b"{}")));
let response = self
.sign_and_dispatch(request, GetAWSOrganizationsAccessStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetAWSOrganizationsAccessStatusOutput, _>()
}
async fn list_accepted_portfolio_shares(
&self,
input: ListAcceptedPortfolioSharesInput,
) -> Result<ListAcceptedPortfolioSharesOutput, RusotoError<ListAcceptedPortfolioSharesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListAcceptedPortfolioShares",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListAcceptedPortfolioSharesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListAcceptedPortfolioSharesOutput, _>()
}
async fn list_budgets_for_resource(
&self,
input: ListBudgetsForResourceInput,
) -> Result<ListBudgetsForResourceOutput, RusotoError<ListBudgetsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListBudgetsForResource",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListBudgetsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListBudgetsForResourceOutput, _>()
}
async fn list_constraints_for_portfolio(
&self,
input: ListConstraintsForPortfolioInput,
) -> Result<ListConstraintsForPortfolioOutput, RusotoError<ListConstraintsForPortfolioError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListConstraintsForPortfolio",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListConstraintsForPortfolioError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListConstraintsForPortfolioOutput, _>()
}
async fn list_launch_paths(
&self,
input: ListLaunchPathsInput,
) -> Result<ListLaunchPathsOutput, RusotoError<ListLaunchPathsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListLaunchPaths",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListLaunchPathsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListLaunchPathsOutput, _>()
}
async fn list_organization_portfolio_access(
&self,
input: ListOrganizationPortfolioAccessInput,
) -> Result<
ListOrganizationPortfolioAccessOutput,
RusotoError<ListOrganizationPortfolioAccessError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListOrganizationPortfolioAccess",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListOrganizationPortfolioAccessError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListOrganizationPortfolioAccessOutput, _>()
}
async fn list_portfolio_access(
&self,
input: ListPortfolioAccessInput,
) -> Result<ListPortfolioAccessOutput, RusotoError<ListPortfolioAccessError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListPortfolioAccess",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListPortfolioAccessError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListPortfolioAccessOutput, _>()
}
async fn list_portfolios(
&self,
input: ListPortfoliosInput,
) -> Result<ListPortfoliosOutput, RusotoError<ListPortfoliosError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWS242ServiceCatalogService.ListPortfolios");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListPortfoliosError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListPortfoliosOutput, _>()
}
async fn list_portfolios_for_product(
&self,
input: ListPortfoliosForProductInput,
) -> Result<ListPortfoliosForProductOutput, RusotoError<ListPortfoliosForProductError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListPortfoliosForProduct",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListPortfoliosForProductError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListPortfoliosForProductOutput, _>()
}
async fn list_principals_for_portfolio(
&self,
input: ListPrincipalsForPortfolioInput,
) -> Result<ListPrincipalsForPortfolioOutput, RusotoError<ListPrincipalsForPortfolioError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListPrincipalsForPortfolio",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListPrincipalsForPortfolioError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListPrincipalsForPortfolioOutput, _>()
}
async fn list_provisioned_product_plans(
&self,
input: ListProvisionedProductPlansInput,
) -> Result<ListProvisionedProductPlansOutput, RusotoError<ListProvisionedProductPlansError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListProvisionedProductPlans",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListProvisionedProductPlansError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListProvisionedProductPlansOutput, _>()
}
async fn list_provisioning_artifacts(
&self,
input: ListProvisioningArtifactsInput,
) -> Result<ListProvisioningArtifactsOutput, RusotoError<ListProvisioningArtifactsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListProvisioningArtifacts",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListProvisioningArtifactsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListProvisioningArtifactsOutput, _>()
}
async fn list_provisioning_artifacts_for_service_action(
&self,
input: ListProvisioningArtifactsForServiceActionInput,
) -> Result<
ListProvisioningArtifactsForServiceActionOutput,
RusotoError<ListProvisioningArtifactsForServiceActionError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListProvisioningArtifactsForServiceAction",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListProvisioningArtifactsForServiceActionError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListProvisioningArtifactsForServiceActionOutput, _>()
}
async fn list_record_history(
&self,
input: ListRecordHistoryInput,
) -> Result<ListRecordHistoryOutput, RusotoError<ListRecordHistoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListRecordHistory",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListRecordHistoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListRecordHistoryOutput, _>()
}
async fn list_resources_for_tag_option(
&self,
input: ListResourcesForTagOptionInput,
) -> Result<ListResourcesForTagOptionOutput, RusotoError<ListResourcesForTagOptionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListResourcesForTagOption",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListResourcesForTagOptionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListResourcesForTagOptionOutput, _>()
}
async fn list_service_actions(
&self,
input: ListServiceActionsInput,
) -> Result<ListServiceActionsOutput, RusotoError<ListServiceActionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListServiceActions",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListServiceActionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListServiceActionsOutput, _>()
}
async fn list_service_actions_for_provisioning_artifact(
&self,
input: ListServiceActionsForProvisioningArtifactInput,
) -> Result<
ListServiceActionsForProvisioningArtifactOutput,
RusotoError<ListServiceActionsForProvisioningArtifactError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListServiceActionsForProvisioningArtifact",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListServiceActionsForProvisioningArtifactError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListServiceActionsForProvisioningArtifactOutput, _>()
}
async fn list_stack_instances_for_provisioned_product(
&self,
input: ListStackInstancesForProvisionedProductInput,
) -> Result<
ListStackInstancesForProvisionedProductOutput,
RusotoError<ListStackInstancesForProvisionedProductError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ListStackInstancesForProvisionedProduct",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListStackInstancesForProvisionedProductError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListStackInstancesForProvisionedProductOutput, _>()
}
async fn list_tag_options(
&self,
input: ListTagOptionsInput,
) -> Result<ListTagOptionsOutput, RusotoError<ListTagOptionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWS242ServiceCatalogService.ListTagOptions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagOptionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagOptionsOutput, _>()
}
async fn provision_product(
&self,
input: ProvisionProductInput,
) -> Result<ProvisionProductOutput, RusotoError<ProvisionProductError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ProvisionProduct",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ProvisionProductError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ProvisionProductOutput, _>()
}
async fn reject_portfolio_share(
&self,
input: RejectPortfolioShareInput,
) -> Result<RejectPortfolioShareOutput, RusotoError<RejectPortfolioShareError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.RejectPortfolioShare",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, RejectPortfolioShareError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<RejectPortfolioShareOutput, _>()
}
async fn scan_provisioned_products(
&self,
input: ScanProvisionedProductsInput,
) -> Result<ScanProvisionedProductsOutput, RusotoError<ScanProvisionedProductsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.ScanProvisionedProducts",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ScanProvisionedProductsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ScanProvisionedProductsOutput, _>()
}
async fn search_products(
&self,
input: SearchProductsInput,
) -> Result<SearchProductsOutput, RusotoError<SearchProductsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWS242ServiceCatalogService.SearchProducts");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SearchProductsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<SearchProductsOutput, _>()
}
async fn search_products_as_admin(
&self,
input: SearchProductsAsAdminInput,
) -> Result<SearchProductsAsAdminOutput, RusotoError<SearchProductsAsAdminError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.SearchProductsAsAdmin",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SearchProductsAsAdminError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<SearchProductsAsAdminOutput, _>()
}
async fn search_provisioned_products(
&self,
input: SearchProvisionedProductsInput,
) -> Result<SearchProvisionedProductsOutput, RusotoError<SearchProvisionedProductsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.SearchProvisionedProducts",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, SearchProvisionedProductsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<SearchProvisionedProductsOutput, _>()
}
async fn terminate_provisioned_product(
&self,
input: TerminateProvisionedProductInput,
) -> Result<TerminateProvisionedProductOutput, RusotoError<TerminateProvisionedProductError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.TerminateProvisionedProduct",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TerminateProvisionedProductError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<TerminateProvisionedProductOutput, _>()
}
async fn update_constraint(
&self,
input: UpdateConstraintInput,
) -> Result<UpdateConstraintOutput, RusotoError<UpdateConstraintError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.UpdateConstraint",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateConstraintError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateConstraintOutput, _>()
}
async fn update_portfolio(
&self,
input: UpdatePortfolioInput,
) -> Result<UpdatePortfolioOutput, RusotoError<UpdatePortfolioError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.UpdatePortfolio",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdatePortfolioError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdatePortfolioOutput, _>()
}
async fn update_product(
&self,
input: UpdateProductInput,
) -> Result<UpdateProductOutput, RusotoError<UpdateProductError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "AWS242ServiceCatalogService.UpdateProduct");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateProductError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateProductOutput, _>()
}
async fn update_provisioned_product(
&self,
input: UpdateProvisionedProductInput,
) -> Result<UpdateProvisionedProductOutput, RusotoError<UpdateProvisionedProductError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.UpdateProvisionedProduct",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateProvisionedProductError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateProvisionedProductOutput, _>()
}
async fn update_provisioned_product_properties(
&self,
input: UpdateProvisionedProductPropertiesInput,
) -> Result<
UpdateProvisionedProductPropertiesOutput,
RusotoError<UpdateProvisionedProductPropertiesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.UpdateProvisionedProductProperties",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
UpdateProvisionedProductPropertiesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateProvisionedProductPropertiesOutput, _>()
}
async fn update_provisioning_artifact(
&self,
input: UpdateProvisioningArtifactInput,
) -> Result<UpdateProvisioningArtifactOutput, RusotoError<UpdateProvisioningArtifactError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.UpdateProvisioningArtifact",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateProvisioningArtifactError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateProvisioningArtifactOutput, _>()
}
async fn update_service_action(
&self,
input: UpdateServiceActionInput,
) -> Result<UpdateServiceActionOutput, RusotoError<UpdateServiceActionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.UpdateServiceAction",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateServiceActionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateServiceActionOutput, _>()
}
async fn update_tag_option(
&self,
input: UpdateTagOptionInput,
) -> Result<UpdateTagOptionOutput, RusotoError<UpdateTagOptionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"AWS242ServiceCatalogService.UpdateTagOption",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateTagOptionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateTagOptionOutput, _>()
}
}