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::param::{Params, ServiceParams};
use rusoto_core::proto;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AccessLogSettings {
#[serde(rename = "DestinationArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_arn: Option<String>,
#[serde(rename = "Format")]
#[serde(skip_serializing_if = "Option::is_none")]
pub format: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Api {
#[serde(rename = "ApiEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_endpoint: Option<String>,
#[serde(rename = "ApiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_id: Option<String>,
#[serde(rename = "ApiKeySelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_selection_expression: Option<String>,
#[serde(rename = "CorsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cors_configuration: Option<Cors>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisableSchemaValidation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_schema_validation: Option<bool>,
#[serde(rename = "ImportInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_info: Option<Vec<String>>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "ProtocolType")]
pub protocol_type: String,
#[serde(rename = "RouteSelectionExpression")]
pub route_selection_expression: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "Warnings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub warnings: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApiMapping {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ApiMappingId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_id: Option<String>,
#[serde(rename = "ApiMappingKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_key: Option<String>,
#[serde(rename = "Stage")]
pub stage: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Authorizer {
#[serde(rename = "AuthorizerCredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_credentials_arn: Option<String>,
#[serde(rename = "AuthorizerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_id: Option<String>,
#[serde(rename = "AuthorizerResultTtlInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_result_ttl_in_seconds: Option<i64>,
#[serde(rename = "AuthorizerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_type: Option<String>,
#[serde(rename = "AuthorizerUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_uri: Option<String>,
#[serde(rename = "IdentitySource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_source: Option<Vec<String>>,
#[serde(rename = "IdentityValidationExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_validation_expression: Option<String>,
#[serde(rename = "JwtConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jwt_configuration: Option<JWTConfiguration>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Cors {
#[serde(rename = "AllowCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_credentials: Option<bool>,
#[serde(rename = "AllowHeaders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_headers: Option<Vec<String>>,
#[serde(rename = "AllowMethods")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_methods: Option<Vec<String>>,
#[serde(rename = "AllowOrigins")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allow_origins: Option<Vec<String>>,
#[serde(rename = "ExposeHeaders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expose_headers: Option<Vec<String>>,
#[serde(rename = "MaxAge")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_age: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApiMappingRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ApiMappingKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_key: Option<String>,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "Stage")]
pub stage: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateApiMappingResponse {
#[serde(rename = "ApiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_id: Option<String>,
#[serde(rename = "ApiMappingId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_id: Option<String>,
#[serde(rename = "ApiMappingKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_key: Option<String>,
#[serde(rename = "Stage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApiRequest {
#[serde(rename = "ApiKeySelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_selection_expression: Option<String>,
#[serde(rename = "CorsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cors_configuration: Option<Cors>,
#[serde(rename = "CredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub credentials_arn: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisableSchemaValidation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_schema_validation: Option<bool>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "ProtocolType")]
pub protocol_type: String,
#[serde(rename = "RouteKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_key: Option<String>,
#[serde(rename = "RouteSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_selection_expression: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateApiResponse {
#[serde(rename = "ApiEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_endpoint: Option<String>,
#[serde(rename = "ApiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_id: Option<String>,
#[serde(rename = "ApiKeySelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_selection_expression: Option<String>,
#[serde(rename = "CorsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cors_configuration: Option<Cors>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisableSchemaValidation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_schema_validation: Option<bool>,
#[serde(rename = "ImportInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_info: Option<Vec<String>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ProtocolType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol_type: Option<String>,
#[serde(rename = "RouteSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_selection_expression: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "Warnings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub warnings: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAuthorizerRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "AuthorizerCredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_credentials_arn: Option<String>,
#[serde(rename = "AuthorizerResultTtlInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_result_ttl_in_seconds: Option<i64>,
#[serde(rename = "AuthorizerType")]
pub authorizer_type: String,
#[serde(rename = "AuthorizerUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_uri: Option<String>,
#[serde(rename = "IdentitySource")]
pub identity_source: Vec<String>,
#[serde(rename = "IdentityValidationExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_validation_expression: Option<String>,
#[serde(rename = "JwtConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jwt_configuration: Option<JWTConfiguration>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAuthorizerResponse {
#[serde(rename = "AuthorizerCredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_credentials_arn: Option<String>,
#[serde(rename = "AuthorizerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_id: Option<String>,
#[serde(rename = "AuthorizerResultTtlInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_result_ttl_in_seconds: Option<i64>,
#[serde(rename = "AuthorizerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_type: Option<String>,
#[serde(rename = "AuthorizerUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_uri: Option<String>,
#[serde(rename = "IdentitySource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_source: Option<Vec<String>>,
#[serde(rename = "IdentityValidationExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_validation_expression: Option<String>,
#[serde(rename = "JwtConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jwt_configuration: Option<JWTConfiguration>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeploymentRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "StageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDeploymentResponse {
#[serde(rename = "AutoDeployed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_deployed: Option<bool>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "DeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status: Option<String>,
#[serde(rename = "DeploymentStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status_message: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDomainNameRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "DomainNameConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name_configurations: Option<Vec<DomainNameConfiguration>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDomainNameResponse {
#[serde(rename = "ApiMappingSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_selection_expression: Option<String>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "DomainNameConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name_configurations: Option<Vec<DomainNameConfiguration>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateIntegrationRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ConnectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_id: Option<String>,
#[serde(rename = "ConnectionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_type: Option<String>,
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "CredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub credentials_arn: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IntegrationMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_method: Option<String>,
#[serde(rename = "IntegrationType")]
pub integration_type: String,
#[serde(rename = "IntegrationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_uri: Option<String>,
#[serde(rename = "PassthroughBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub passthrough_behavior: Option<String>,
#[serde(rename = "PayloadFormatVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub payload_format_version: Option<String>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
#[serde(rename = "TimeoutInMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout_in_millis: Option<i64>,
#[serde(rename = "TlsConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tls_config: Option<TlsConfigInput>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateIntegrationResponseRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "IntegrationId")]
pub integration_id: String,
#[serde(rename = "IntegrationResponseKey")]
pub integration_response_key: String,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateIntegrationResponseResponse {
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "IntegrationResponseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_id: Option<String>,
#[serde(rename = "IntegrationResponseKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_key: Option<String>,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateIntegrationResult {
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "ConnectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_id: Option<String>,
#[serde(rename = "ConnectionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_type: Option<String>,
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "CredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub credentials_arn: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IntegrationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_id: Option<String>,
#[serde(rename = "IntegrationMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_method: Option<String>,
#[serde(rename = "IntegrationResponseSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_selection_expression: Option<String>,
#[serde(rename = "IntegrationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_type: Option<String>,
#[serde(rename = "IntegrationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_uri: Option<String>,
#[serde(rename = "PassthroughBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub passthrough_behavior: Option<String>,
#[serde(rename = "PayloadFormatVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub payload_format_version: Option<String>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
#[serde(rename = "TimeoutInMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout_in_millis: Option<i64>,
#[serde(rename = "TlsConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tls_config: Option<TlsConfig>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateModelRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Schema")]
pub schema: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateModelResponse {
#[serde(rename = "ContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ModelId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Schema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateRouteRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ApiKeyRequired")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_required: Option<bool>,
#[serde(rename = "AuthorizationScopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_scopes: Option<Vec<String>>,
#[serde(rename = "AuthorizationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_type: Option<String>,
#[serde(rename = "AuthorizerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_id: Option<String>,
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "OperationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_name: Option<String>,
#[serde(rename = "RequestModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteKey")]
pub route_key: String,
#[serde(rename = "RouteResponseSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_selection_expression: Option<String>,
#[serde(rename = "Target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateRouteResponseRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "ResponseModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteId")]
pub route_id: String,
#[serde(rename = "RouteResponseKey")]
pub route_response_key: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateRouteResponseResponse {
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "ResponseModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteResponseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_id: Option<String>,
#[serde(rename = "RouteResponseKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_key: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateRouteResult {
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "ApiKeyRequired")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_required: Option<bool>,
#[serde(rename = "AuthorizationScopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_scopes: Option<Vec<String>>,
#[serde(rename = "AuthorizationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_type: Option<String>,
#[serde(rename = "AuthorizerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_id: Option<String>,
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "OperationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_name: Option<String>,
#[serde(rename = "RequestModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_id: Option<String>,
#[serde(rename = "RouteKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_key: Option<String>,
#[serde(rename = "RouteResponseSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_selection_expression: Option<String>,
#[serde(rename = "Target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateStageRequest {
#[serde(rename = "AccessLogSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_log_settings: Option<AccessLogSettings>,
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "AutoDeploy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_deploy: Option<bool>,
#[serde(rename = "ClientCertificateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_certificate_id: Option<String>,
#[serde(rename = "DefaultRouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_route_settings: Option<RouteSettings>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "RouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_settings: Option<::std::collections::HashMap<String, RouteSettings>>,
#[serde(rename = "StageName")]
pub stage_name: String,
#[serde(rename = "StageVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateStageResponse {
#[serde(rename = "AccessLogSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_log_settings: Option<AccessLogSettings>,
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "AutoDeploy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_deploy: Option<bool>,
#[serde(rename = "ClientCertificateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_certificate_id: Option<String>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "DefaultRouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_route_settings: Option<RouteSettings>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastDeploymentStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_status_message: Option<String>,
#[serde(rename = "LastUpdatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date: Option<f64>,
#[serde(rename = "RouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_settings: Option<::std::collections::HashMap<String, RouteSettings>>,
#[serde(rename = "StageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_name: Option<String>,
#[serde(rename = "StageVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateVpcLinkRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SubnetIds")]
pub subnet_ids: Vec<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateVpcLinkResponse {
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "VpcLinkId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_id: Option<String>,
#[serde(rename = "VpcLinkStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_status: Option<String>,
#[serde(rename = "VpcLinkStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_status_message: Option<String>,
#[serde(rename = "VpcLinkVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAccessLogSettingsRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "StageName")]
pub stage_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApiMappingRequest {
#[serde(rename = "ApiMappingId")]
pub api_mapping_id: String,
#[serde(rename = "DomainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApiRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAuthorizerRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "AuthorizerId")]
pub authorizer_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCorsConfigurationRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDeploymentRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "DeploymentId")]
pub deployment_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDomainNameRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteIntegrationRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "IntegrationId")]
pub integration_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteIntegrationResponseRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "IntegrationId")]
pub integration_id: String,
#[serde(rename = "IntegrationResponseId")]
pub integration_response_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteModelRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ModelId")]
pub model_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRouteRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "RouteId")]
pub route_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRouteRequestParameterRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "RequestParameterKey")]
pub request_parameter_key: String,
#[serde(rename = "RouteId")]
pub route_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRouteResponseRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "RouteId")]
pub route_id: String,
#[serde(rename = "RouteResponseId")]
pub route_response_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRouteSettingsRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "RouteKey")]
pub route_key: String,
#[serde(rename = "StageName")]
pub stage_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteStageRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "StageName")]
pub stage_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteVpcLinkRequest {
#[serde(rename = "VpcLinkId")]
pub vpc_link_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteVpcLinkResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Deployment {
#[serde(rename = "AutoDeployed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_deployed: Option<bool>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "DeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status: Option<String>,
#[serde(rename = "DeploymentStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status_message: 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 DomainName {
#[serde(rename = "ApiMappingSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_selection_expression: Option<String>,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "DomainNameConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name_configurations: Option<Vec<DomainNameConfiguration>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DomainNameConfiguration {
#[serde(rename = "ApiGatewayDomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_domain_name: Option<String>,
#[serde(rename = "CertificateArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_arn: Option<String>,
#[serde(rename = "CertificateName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_name: Option<String>,
#[serde(rename = "CertificateUploadDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_upload_date: Option<f64>,
#[serde(rename = "DomainNameStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name_status: Option<String>,
#[serde(rename = "DomainNameStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name_status_message: Option<String>,
#[serde(rename = "EndpointType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint_type: Option<String>,
#[serde(rename = "HostedZoneId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hosted_zone_id: Option<String>,
#[serde(rename = "SecurityPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_policy: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ExportApiRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ExportVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub export_version: Option<String>,
#[serde(rename = "IncludeExtensions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_extensions: Option<bool>,
#[serde(rename = "OutputType")]
pub output_type: String,
#[serde(rename = "Specification")]
pub specification: String,
#[serde(rename = "StageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct ExportApiResponse {
pub body: Option<bytes::Bytes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetApiMappingRequest {
#[serde(rename = "ApiMappingId")]
pub api_mapping_id: String,
#[serde(rename = "DomainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetApiMappingResponse {
#[serde(rename = "ApiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_id: Option<String>,
#[serde(rename = "ApiMappingId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_id: Option<String>,
#[serde(rename = "ApiMappingKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_key: Option<String>,
#[serde(rename = "Stage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetApiMappingsRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetApiMappingsResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<ApiMapping>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetApiRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetApiResponse {
#[serde(rename = "ApiEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_endpoint: Option<String>,
#[serde(rename = "ApiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_id: Option<String>,
#[serde(rename = "ApiKeySelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_selection_expression: Option<String>,
#[serde(rename = "CorsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cors_configuration: Option<Cors>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisableSchemaValidation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_schema_validation: Option<bool>,
#[serde(rename = "ImportInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_info: Option<Vec<String>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ProtocolType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol_type: Option<String>,
#[serde(rename = "RouteSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_selection_expression: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "Warnings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub warnings: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetApisRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetApisResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<Api>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAuthorizerRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "AuthorizerId")]
pub authorizer_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAuthorizerResponse {
#[serde(rename = "AuthorizerCredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_credentials_arn: Option<String>,
#[serde(rename = "AuthorizerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_id: Option<String>,
#[serde(rename = "AuthorizerResultTtlInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_result_ttl_in_seconds: Option<i64>,
#[serde(rename = "AuthorizerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_type: Option<String>,
#[serde(rename = "AuthorizerUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_uri: Option<String>,
#[serde(rename = "IdentitySource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_source: Option<Vec<String>>,
#[serde(rename = "IdentityValidationExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_validation_expression: Option<String>,
#[serde(rename = "JwtConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jwt_configuration: Option<JWTConfiguration>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAuthorizersRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAuthorizersResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<Authorizer>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeploymentRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "DeploymentId")]
pub deployment_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeploymentResponse {
#[serde(rename = "AutoDeployed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_deployed: Option<bool>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "DeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status: Option<String>,
#[serde(rename = "DeploymentStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status_message: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDeploymentsRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDeploymentsResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<Deployment>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDomainNameRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDomainNameResponse {
#[serde(rename = "ApiMappingSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_selection_expression: Option<String>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "DomainNameConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name_configurations: Option<Vec<DomainNameConfiguration>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDomainNamesRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDomainNamesResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<DomainName>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetIntegrationRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "IntegrationId")]
pub integration_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetIntegrationResponseRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "IntegrationId")]
pub integration_id: String,
#[serde(rename = "IntegrationResponseId")]
pub integration_response_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetIntegrationResponseResponse {
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "IntegrationResponseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_id: Option<String>,
#[serde(rename = "IntegrationResponseKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_key: Option<String>,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetIntegrationResponsesRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "IntegrationId")]
pub integration_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetIntegrationResponsesResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<IntegrationResponse>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetIntegrationResult {
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "ConnectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_id: Option<String>,
#[serde(rename = "ConnectionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_type: Option<String>,
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "CredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub credentials_arn: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IntegrationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_id: Option<String>,
#[serde(rename = "IntegrationMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_method: Option<String>,
#[serde(rename = "IntegrationResponseSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_selection_expression: Option<String>,
#[serde(rename = "IntegrationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_type: Option<String>,
#[serde(rename = "IntegrationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_uri: Option<String>,
#[serde(rename = "PassthroughBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub passthrough_behavior: Option<String>,
#[serde(rename = "PayloadFormatVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub payload_format_version: Option<String>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
#[serde(rename = "TimeoutInMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout_in_millis: Option<i64>,
#[serde(rename = "TlsConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tls_config: Option<TlsConfig>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetIntegrationsRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetIntegrationsResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<Integration>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetModelRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ModelId")]
pub model_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetModelResponse {
#[serde(rename = "ContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ModelId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Schema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetModelTemplateRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ModelId")]
pub model_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetModelTemplateResponse {
#[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 GetModelsRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetModelsResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<Model>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRouteRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "RouteId")]
pub route_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRouteResponseRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "RouteId")]
pub route_id: String,
#[serde(rename = "RouteResponseId")]
pub route_response_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRouteResponseResponse {
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "ResponseModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteResponseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_id: Option<String>,
#[serde(rename = "RouteResponseKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_key: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRouteResponsesRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "RouteId")]
pub route_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRouteResponsesResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<RouteResponse>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRouteResult {
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "ApiKeyRequired")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_required: Option<bool>,
#[serde(rename = "AuthorizationScopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_scopes: Option<Vec<String>>,
#[serde(rename = "AuthorizationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_type: Option<String>,
#[serde(rename = "AuthorizerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_id: Option<String>,
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "OperationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_name: Option<String>,
#[serde(rename = "RequestModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_id: Option<String>,
#[serde(rename = "RouteKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_key: Option<String>,
#[serde(rename = "RouteResponseSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_selection_expression: Option<String>,
#[serde(rename = "Target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRoutesRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRoutesResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<Route>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetStageRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "StageName")]
pub stage_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetStageResponse {
#[serde(rename = "AccessLogSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_log_settings: Option<AccessLogSettings>,
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "AutoDeploy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_deploy: Option<bool>,
#[serde(rename = "ClientCertificateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_certificate_id: Option<String>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "DefaultRouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_route_settings: Option<RouteSettings>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastDeploymentStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_status_message: Option<String>,
#[serde(rename = "LastUpdatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date: Option<f64>,
#[serde(rename = "RouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_settings: Option<::std::collections::HashMap<String, RouteSettings>>,
#[serde(rename = "StageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_name: Option<String>,
#[serde(rename = "StageVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetStagesRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetStagesResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<Stage>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTagsRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetTagsResponse {
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetVpcLinkRequest {
#[serde(rename = "VpcLinkId")]
pub vpc_link_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetVpcLinkResponse {
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "VpcLinkId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_id: Option<String>,
#[serde(rename = "VpcLinkStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_status: Option<String>,
#[serde(rename = "VpcLinkStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_status_message: Option<String>,
#[serde(rename = "VpcLinkVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetVpcLinksRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<String>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetVpcLinksResponse {
#[serde(rename = "Items")]
#[serde(skip_serializing_if = "Option::is_none")]
pub items: Option<Vec<VpcLink>>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ImportApiRequest {
#[serde(rename = "Basepath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub basepath: Option<String>,
#[serde(rename = "Body")]
pub body: String,
#[serde(rename = "FailOnWarnings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fail_on_warnings: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImportApiResponse {
#[serde(rename = "ApiEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_endpoint: Option<String>,
#[serde(rename = "ApiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_id: Option<String>,
#[serde(rename = "ApiKeySelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_selection_expression: Option<String>,
#[serde(rename = "CorsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cors_configuration: Option<Cors>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisableSchemaValidation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_schema_validation: Option<bool>,
#[serde(rename = "ImportInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_info: Option<Vec<String>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ProtocolType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol_type: Option<String>,
#[serde(rename = "RouteSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_selection_expression: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "Warnings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub warnings: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Integration {
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "ConnectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_id: Option<String>,
#[serde(rename = "ConnectionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_type: Option<String>,
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "CredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub credentials_arn: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IntegrationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_id: Option<String>,
#[serde(rename = "IntegrationMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_method: Option<String>,
#[serde(rename = "IntegrationResponseSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_selection_expression: Option<String>,
#[serde(rename = "IntegrationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_type: Option<String>,
#[serde(rename = "IntegrationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_uri: Option<String>,
#[serde(rename = "PassthroughBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub passthrough_behavior: Option<String>,
#[serde(rename = "PayloadFormatVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub payload_format_version: Option<String>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
#[serde(rename = "TimeoutInMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout_in_millis: Option<i64>,
#[serde(rename = "TlsConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tls_config: Option<TlsConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IntegrationResponse {
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "IntegrationResponseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_id: Option<String>,
#[serde(rename = "IntegrationResponseKey")]
pub integration_response_key: String,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct JWTConfiguration {
#[serde(rename = "Audience")]
#[serde(skip_serializing_if = "Option::is_none")]
pub audience: Option<Vec<String>>,
#[serde(rename = "Issuer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub issuer: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Model {
#[serde(rename = "ContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ModelId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_id: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "Schema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ParameterConstraints {
#[serde(rename = "Required")]
#[serde(skip_serializing_if = "Option::is_none")]
pub required: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ReimportApiRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "Basepath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub basepath: Option<String>,
#[serde(rename = "Body")]
pub body: String,
#[serde(rename = "FailOnWarnings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub fail_on_warnings: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReimportApiResponse {
#[serde(rename = "ApiEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_endpoint: Option<String>,
#[serde(rename = "ApiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_id: Option<String>,
#[serde(rename = "ApiKeySelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_selection_expression: Option<String>,
#[serde(rename = "CorsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cors_configuration: Option<Cors>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisableSchemaValidation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_schema_validation: Option<bool>,
#[serde(rename = "ImportInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_info: Option<Vec<String>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ProtocolType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol_type: Option<String>,
#[serde(rename = "RouteSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_selection_expression: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "Warnings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub warnings: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Route {
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "ApiKeyRequired")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_required: Option<bool>,
#[serde(rename = "AuthorizationScopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_scopes: Option<Vec<String>>,
#[serde(rename = "AuthorizationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_type: Option<String>,
#[serde(rename = "AuthorizerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_id: Option<String>,
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "OperationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_name: Option<String>,
#[serde(rename = "RequestModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_id: Option<String>,
#[serde(rename = "RouteKey")]
pub route_key: String,
#[serde(rename = "RouteResponseSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_selection_expression: Option<String>,
#[serde(rename = "Target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RouteResponse {
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "ResponseModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteResponseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_id: Option<String>,
#[serde(rename = "RouteResponseKey")]
pub route_response_key: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RouteSettings {
#[serde(rename = "DataTraceEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_trace_enabled: Option<bool>,
#[serde(rename = "DetailedMetricsEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detailed_metrics_enabled: Option<bool>,
#[serde(rename = "LoggingLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub logging_level: Option<String>,
#[serde(rename = "ThrottlingBurstLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub throttling_burst_limit: Option<i64>,
#[serde(rename = "ThrottlingRateLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub throttling_rate_limit: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Stage {
#[serde(rename = "AccessLogSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_log_settings: Option<AccessLogSettings>,
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "AutoDeploy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_deploy: Option<bool>,
#[serde(rename = "ClientCertificateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_certificate_id: Option<String>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "DefaultRouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_route_settings: Option<RouteSettings>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastDeploymentStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_status_message: Option<String>,
#[serde(rename = "LastUpdatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date: Option<f64>,
#[serde(rename = "RouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_settings: Option<::std::collections::HashMap<String, RouteSettings>>,
#[serde(rename = "StageName")]
pub stage_name: String,
#[serde(rename = "StageVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TlsConfig {
#[serde(rename = "ServerNameToVerify")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_name_to_verify: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TlsConfigInput {
#[serde(rename = "ServerNameToVerify")]
#[serde(skip_serializing_if = "Option::is_none")]
pub server_name_to_verify: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApiMappingRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ApiMappingId")]
pub api_mapping_id: String,
#[serde(rename = "ApiMappingKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_key: Option<String>,
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "Stage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateApiMappingResponse {
#[serde(rename = "ApiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_id: Option<String>,
#[serde(rename = "ApiMappingId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_id: Option<String>,
#[serde(rename = "ApiMappingKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_key: Option<String>,
#[serde(rename = "Stage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApiRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ApiKeySelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_selection_expression: Option<String>,
#[serde(rename = "CorsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cors_configuration: Option<Cors>,
#[serde(rename = "CredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub credentials_arn: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisableSchemaValidation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_schema_validation: Option<bool>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "RouteKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_key: Option<String>,
#[serde(rename = "RouteSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_selection_expression: Option<String>,
#[serde(rename = "Target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateApiResponse {
#[serde(rename = "ApiEndpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_endpoint: Option<String>,
#[serde(rename = "ApiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_id: Option<String>,
#[serde(rename = "ApiKeySelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_selection_expression: Option<String>,
#[serde(rename = "CorsConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub cors_configuration: Option<Cors>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "DisableSchemaValidation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub disable_schema_validation: Option<bool>,
#[serde(rename = "ImportInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub import_info: Option<Vec<String>>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ProtocolType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub protocol_type: Option<String>,
#[serde(rename = "RouteSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_selection_expression: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "Warnings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub warnings: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAuthorizerRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "AuthorizerCredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_credentials_arn: Option<String>,
#[serde(rename = "AuthorizerId")]
pub authorizer_id: String,
#[serde(rename = "AuthorizerResultTtlInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_result_ttl_in_seconds: Option<i64>,
#[serde(rename = "AuthorizerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_type: Option<String>,
#[serde(rename = "AuthorizerUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_uri: Option<String>,
#[serde(rename = "IdentitySource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_source: Option<Vec<String>>,
#[serde(rename = "IdentityValidationExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_validation_expression: Option<String>,
#[serde(rename = "JwtConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jwt_configuration: Option<JWTConfiguration>,
#[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 UpdateAuthorizerResponse {
#[serde(rename = "AuthorizerCredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_credentials_arn: Option<String>,
#[serde(rename = "AuthorizerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_id: Option<String>,
#[serde(rename = "AuthorizerResultTtlInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_result_ttl_in_seconds: Option<i64>,
#[serde(rename = "AuthorizerType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_type: Option<String>,
#[serde(rename = "AuthorizerUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_uri: Option<String>,
#[serde(rename = "IdentitySource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_source: Option<Vec<String>>,
#[serde(rename = "IdentityValidationExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_validation_expression: Option<String>,
#[serde(rename = "JwtConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub jwt_configuration: Option<JWTConfiguration>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDeploymentRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "DeploymentId")]
pub deployment_id: 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 UpdateDeploymentResponse {
#[serde(rename = "AutoDeployed")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_deployed: Option<bool>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "DeploymentStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status: Option<String>,
#[serde(rename = "DeploymentStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_status_message: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDomainNameRequest {
#[serde(rename = "DomainName")]
pub domain_name: String,
#[serde(rename = "DomainNameConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name_configurations: Option<Vec<DomainNameConfiguration>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDomainNameResponse {
#[serde(rename = "ApiMappingSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_mapping_selection_expression: Option<String>,
#[serde(rename = "DomainName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name: Option<String>,
#[serde(rename = "DomainNameConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub domain_name_configurations: Option<Vec<DomainNameConfiguration>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateIntegrationRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ConnectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_id: Option<String>,
#[serde(rename = "ConnectionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_type: Option<String>,
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "CredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub credentials_arn: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IntegrationId")]
pub integration_id: String,
#[serde(rename = "IntegrationMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_method: Option<String>,
#[serde(rename = "IntegrationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_type: Option<String>,
#[serde(rename = "IntegrationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_uri: Option<String>,
#[serde(rename = "PassthroughBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub passthrough_behavior: Option<String>,
#[serde(rename = "PayloadFormatVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub payload_format_version: Option<String>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
#[serde(rename = "TimeoutInMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout_in_millis: Option<i64>,
#[serde(rename = "TlsConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tls_config: Option<TlsConfigInput>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateIntegrationResponseRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "IntegrationId")]
pub integration_id: String,
#[serde(rename = "IntegrationResponseId")]
pub integration_response_id: String,
#[serde(rename = "IntegrationResponseKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_key: Option<String>,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateIntegrationResponseResponse {
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "IntegrationResponseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_id: Option<String>,
#[serde(rename = "IntegrationResponseKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_key: Option<String>,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateIntegrationResult {
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "ConnectionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_id: Option<String>,
#[serde(rename = "ConnectionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub connection_type: Option<String>,
#[serde(rename = "ContentHandlingStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_handling_strategy: Option<String>,
#[serde(rename = "CredentialsArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub credentials_arn: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "IntegrationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_id: Option<String>,
#[serde(rename = "IntegrationMethod")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_method: Option<String>,
#[serde(rename = "IntegrationResponseSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_response_selection_expression: Option<String>,
#[serde(rename = "IntegrationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_type: Option<String>,
#[serde(rename = "IntegrationUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub integration_uri: Option<String>,
#[serde(rename = "PassthroughBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub passthrough_behavior: Option<String>,
#[serde(rename = "PayloadFormatVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub payload_format_version: Option<String>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestTemplates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_templates: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "TemplateSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub template_selection_expression: Option<String>,
#[serde(rename = "TimeoutInMillis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout_in_millis: Option<i64>,
#[serde(rename = "TlsConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tls_config: Option<TlsConfig>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateModelRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ModelId")]
pub model_id: String,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Schema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateModelResponse {
#[serde(rename = "ContentType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_type: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "ModelId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_id: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Schema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRouteRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ApiKeyRequired")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_required: Option<bool>,
#[serde(rename = "AuthorizationScopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_scopes: Option<Vec<String>>,
#[serde(rename = "AuthorizationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_type: Option<String>,
#[serde(rename = "AuthorizerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_id: Option<String>,
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "OperationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_name: Option<String>,
#[serde(rename = "RequestModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteId")]
pub route_id: String,
#[serde(rename = "RouteKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_key: Option<String>,
#[serde(rename = "RouteResponseSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_selection_expression: Option<String>,
#[serde(rename = "Target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRouteResponseRequest {
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "ResponseModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteId")]
pub route_id: String,
#[serde(rename = "RouteResponseId")]
pub route_response_id: String,
#[serde(rename = "RouteResponseKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_key: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateRouteResponseResponse {
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "ResponseModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ResponseParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteResponseId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_id: Option<String>,
#[serde(rename = "RouteResponseKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_key: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateRouteResult {
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "ApiKeyRequired")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key_required: Option<bool>,
#[serde(rename = "AuthorizationScopes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_scopes: Option<Vec<String>>,
#[serde(rename = "AuthorizationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_type: Option<String>,
#[serde(rename = "AuthorizerId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorizer_id: Option<String>,
#[serde(rename = "ModelSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub model_selection_expression: Option<String>,
#[serde(rename = "OperationName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub operation_name: Option<String>,
#[serde(rename = "RequestModels")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_models: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "RequestParameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_parameters: Option<::std::collections::HashMap<String, ParameterConstraints>>,
#[serde(rename = "RouteId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_id: Option<String>,
#[serde(rename = "RouteKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_key: Option<String>,
#[serde(rename = "RouteResponseSelectionExpression")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_response_selection_expression: Option<String>,
#[serde(rename = "Target")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateStageRequest {
#[serde(rename = "AccessLogSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_log_settings: Option<AccessLogSettings>,
#[serde(rename = "ApiId")]
pub api_id: String,
#[serde(rename = "AutoDeploy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_deploy: Option<bool>,
#[serde(rename = "ClientCertificateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_certificate_id: Option<String>,
#[serde(rename = "DefaultRouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_route_settings: Option<RouteSettings>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "RouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_settings: Option<::std::collections::HashMap<String, RouteSettings>>,
#[serde(rename = "StageName")]
pub stage_name: String,
#[serde(rename = "StageVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_variables: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateStageResponse {
#[serde(rename = "AccessLogSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_log_settings: Option<AccessLogSettings>,
#[serde(rename = "ApiGatewayManaged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_gateway_managed: Option<bool>,
#[serde(rename = "AutoDeploy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_deploy: Option<bool>,
#[serde(rename = "ClientCertificateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_certificate_id: Option<String>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "DefaultRouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_route_settings: Option<RouteSettings>,
#[serde(rename = "DeploymentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_id: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastDeploymentStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deployment_status_message: Option<String>,
#[serde(rename = "LastUpdatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_updated_date: Option<f64>,
#[serde(rename = "RouteSettings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub route_settings: Option<::std::collections::HashMap<String, RouteSettings>>,
#[serde(rename = "StageName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_name: Option<String>,
#[serde(rename = "StageVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateVpcLinkRequest {
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "VpcLinkId")]
pub vpc_link_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateVpcLinkResponse {
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "VpcLinkId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_id: Option<String>,
#[serde(rename = "VpcLinkStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_status: Option<String>,
#[serde(rename = "VpcLinkStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_status_message: Option<String>,
#[serde(rename = "VpcLinkVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_version: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VpcLink {
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<f64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SecurityGroupIds")]
pub security_group_ids: Vec<String>,
#[serde(rename = "SubnetIds")]
pub subnet_ids: Vec<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "VpcLinkId")]
pub vpc_link_id: String,
#[serde(rename = "VpcLinkStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_status: Option<String>,
#[serde(rename = "VpcLinkStatusMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_status_message: Option<String>,
#[serde(rename = "VpcLinkVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_link_version: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum CreateApiError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateApiError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateApiError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateApiError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateApiError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateApiError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateApiError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateApiError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateApiError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateApiError::Conflict(ref cause) => write!(f, "{}", cause),
CreateApiError::NotFound(ref cause) => write!(f, "{}", cause),
CreateApiError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateApiError {}
#[derive(Debug, PartialEq)]
pub enum CreateApiMappingError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateApiMappingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateApiMappingError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateApiMappingError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateApiMappingError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateApiMappingError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateApiMappingError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateApiMappingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateApiMappingError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateApiMappingError::Conflict(ref cause) => write!(f, "{}", cause),
CreateApiMappingError::NotFound(ref cause) => write!(f, "{}", cause),
CreateApiMappingError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateApiMappingError {}
#[derive(Debug, PartialEq)]
pub enum CreateAuthorizerError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateAuthorizerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAuthorizerError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateAuthorizerError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateAuthorizerError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateAuthorizerError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateAuthorizerError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateAuthorizerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateAuthorizerError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateAuthorizerError::Conflict(ref cause) => write!(f, "{}", cause),
CreateAuthorizerError::NotFound(ref cause) => write!(f, "{}", cause),
CreateAuthorizerError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateAuthorizerError {}
#[derive(Debug, PartialEq)]
pub enum CreateDeploymentError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateDeploymentError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateDeploymentError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateDeploymentError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateDeploymentError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDeploymentError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::Conflict(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum CreateDomainNameError {
AccessDenied(String),
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateDomainNameError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDomainNameError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateDomainNameError::AccessDenied(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(CreateDomainNameError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateDomainNameError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateDomainNameError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateDomainNameError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDomainNameError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDomainNameError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateDomainNameError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateDomainNameError::Conflict(ref cause) => write!(f, "{}", cause),
CreateDomainNameError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDomainNameError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDomainNameError {}
#[derive(Debug, PartialEq)]
pub enum CreateIntegrationError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateIntegrationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateIntegrationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateIntegrationError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateIntegrationError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateIntegrationError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateIntegrationError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateIntegrationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateIntegrationError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateIntegrationError::Conflict(ref cause) => write!(f, "{}", cause),
CreateIntegrationError::NotFound(ref cause) => write!(f, "{}", cause),
CreateIntegrationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateIntegrationError {}
#[derive(Debug, PartialEq)]
pub enum CreateIntegrationResponseError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateIntegrationResponseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateIntegrationResponseError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateIntegrationResponseError::BadRequest(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(CreateIntegrationResponseError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateIntegrationResponseError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateIntegrationResponseError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateIntegrationResponseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateIntegrationResponseError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateIntegrationResponseError::Conflict(ref cause) => write!(f, "{}", cause),
CreateIntegrationResponseError::NotFound(ref cause) => write!(f, "{}", cause),
CreateIntegrationResponseError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateIntegrationResponseError {}
#[derive(Debug, PartialEq)]
pub enum CreateModelError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateModelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateModelError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateModelError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateModelError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateModelError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateModelError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateModelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateModelError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateModelError::Conflict(ref cause) => write!(f, "{}", cause),
CreateModelError::NotFound(ref cause) => write!(f, "{}", cause),
CreateModelError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateModelError {}
#[derive(Debug, PartialEq)]
pub enum CreateRouteError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateRouteError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateRouteError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateRouteError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateRouteError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateRouteError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateRouteError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateRouteError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateRouteError::Conflict(ref cause) => write!(f, "{}", cause),
CreateRouteError::NotFound(ref cause) => write!(f, "{}", cause),
CreateRouteError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateRouteError {}
#[derive(Debug, PartialEq)]
pub enum CreateRouteResponseError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateRouteResponseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateRouteResponseError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateRouteResponseError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateRouteResponseError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateRouteResponseError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateRouteResponseError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateRouteResponseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateRouteResponseError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateRouteResponseError::Conflict(ref cause) => write!(f, "{}", cause),
CreateRouteResponseError::NotFound(ref cause) => write!(f, "{}", cause),
CreateRouteResponseError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateRouteResponseError {}
#[derive(Debug, PartialEq)]
pub enum CreateStageError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl CreateStageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateStageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateStageError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(CreateStageError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateStageError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateStageError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateStageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateStageError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateStageError::Conflict(ref cause) => write!(f, "{}", cause),
CreateStageError::NotFound(ref cause) => write!(f, "{}", cause),
CreateStageError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateStageError {}
#[derive(Debug, PartialEq)]
pub enum CreateVpcLinkError {
BadRequest(String),
TooManyRequests(String),
}
impl CreateVpcLinkError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateVpcLinkError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateVpcLinkError::BadRequest(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateVpcLinkError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateVpcLinkError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateVpcLinkError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateVpcLinkError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateVpcLinkError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAccessLogSettingsError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteAccessLogSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAccessLogSettingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteAccessLogSettingsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteAccessLogSettingsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAccessLogSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAccessLogSettingsError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteAccessLogSettingsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAccessLogSettingsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApiError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteApiError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApiError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteApiError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteApiError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApiError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApiError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteApiError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteApiError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApiMappingError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl DeleteApiMappingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApiMappingError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteApiMappingError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteApiMappingError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteApiMappingError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApiMappingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApiMappingError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteApiMappingError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteApiMappingError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteApiMappingError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAuthorizerError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteAuthorizerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAuthorizerError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteAuthorizerError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteAuthorizerError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAuthorizerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAuthorizerError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteAuthorizerError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAuthorizerError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCorsConfigurationError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteCorsConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCorsConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteCorsConfigurationError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteCorsConfigurationError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteCorsConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCorsConfigurationError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteCorsConfigurationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteCorsConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDeploymentError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteDeploymentError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteDeploymentError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDeploymentError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteDeploymentError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDomainNameError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteDomainNameError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDomainNameError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteDomainNameError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteDomainNameError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDomainNameError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDomainNameError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteDomainNameError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDomainNameError {}
#[derive(Debug, PartialEq)]
pub enum DeleteIntegrationError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteIntegrationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteIntegrationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteIntegrationError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteIntegrationError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteIntegrationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteIntegrationError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteIntegrationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteIntegrationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteIntegrationResponseError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteIntegrationResponseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteIntegrationResponseError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteIntegrationResponseError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteIntegrationResponseError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteIntegrationResponseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteIntegrationResponseError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteIntegrationResponseError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteIntegrationResponseError {}
#[derive(Debug, PartialEq)]
pub enum DeleteModelError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteModelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteModelError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteModelError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteModelError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteModelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteModelError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteModelError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteModelError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRouteError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRouteError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteRouteError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteRouteError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRouteError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRouteError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteRouteError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteRouteError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRouteRequestParameterError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteRouteRequestParameterError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteRouteRequestParameterError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteRouteRequestParameterError::NotFound(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteRouteRequestParameterError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRouteRequestParameterError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRouteRequestParameterError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteRouteRequestParameterError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteRouteRequestParameterError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRouteResponseError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteRouteResponseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRouteResponseError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteRouteResponseError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteRouteResponseError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRouteResponseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRouteResponseError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteRouteResponseError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteRouteResponseError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRouteSettingsError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteRouteSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRouteSettingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteRouteSettingsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteRouteSettingsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRouteSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRouteSettingsError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteRouteSettingsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteRouteSettingsError {}
#[derive(Debug, PartialEq)]
pub enum DeleteStageError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteStageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteStageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteStageError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteStageError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteStageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteStageError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteStageError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteStageError {}
#[derive(Debug, PartialEq)]
pub enum DeleteVpcLinkError {
NotFound(String),
TooManyRequests(String),
}
impl DeleteVpcLinkError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteVpcLinkError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(DeleteVpcLinkError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteVpcLinkError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteVpcLinkError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteVpcLinkError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteVpcLinkError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteVpcLinkError {}
#[derive(Debug, PartialEq)]
pub enum ExportApiError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl ExportApiError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ExportApiError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ExportApiError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ExportApiError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ExportApiError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ExportApiError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ExportApiError::BadRequest(ref cause) => write!(f, "{}", cause),
ExportApiError::NotFound(ref cause) => write!(f, "{}", cause),
ExportApiError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ExportApiError {}
#[derive(Debug, PartialEq)]
pub enum GetApiError {
NotFound(String),
TooManyRequests(String),
}
impl GetApiError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetApiError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => return RusotoError::Service(GetApiError::NotFound(err.msg)),
"TooManyRequestsException" => {
return RusotoError::Service(GetApiError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetApiError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetApiError::NotFound(ref cause) => write!(f, "{}", cause),
GetApiError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetApiError {}
#[derive(Debug, PartialEq)]
pub enum GetApiMappingError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetApiMappingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetApiMappingError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetApiMappingError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetApiMappingError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetApiMappingError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetApiMappingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetApiMappingError::BadRequest(ref cause) => write!(f, "{}", cause),
GetApiMappingError::NotFound(ref cause) => write!(f, "{}", cause),
GetApiMappingError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetApiMappingError {}
#[derive(Debug, PartialEq)]
pub enum GetApiMappingsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetApiMappingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetApiMappingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetApiMappingsError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetApiMappingsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetApiMappingsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetApiMappingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetApiMappingsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetApiMappingsError::NotFound(ref cause) => write!(f, "{}", cause),
GetApiMappingsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetApiMappingsError {}
#[derive(Debug, PartialEq)]
pub enum GetApisError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetApisError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetApisError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetApisError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetApisError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetApisError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetApisError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetApisError::BadRequest(ref cause) => write!(f, "{}", cause),
GetApisError::NotFound(ref cause) => write!(f, "{}", cause),
GetApisError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetApisError {}
#[derive(Debug, PartialEq)]
pub enum GetAuthorizerError {
NotFound(String),
TooManyRequests(String),
}
impl GetAuthorizerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAuthorizerError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(GetAuthorizerError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetAuthorizerError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAuthorizerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAuthorizerError::NotFound(ref cause) => write!(f, "{}", cause),
GetAuthorizerError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAuthorizerError {}
#[derive(Debug, PartialEq)]
pub enum GetAuthorizersError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetAuthorizersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAuthorizersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetAuthorizersError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetAuthorizersError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetAuthorizersError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAuthorizersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAuthorizersError::BadRequest(ref cause) => write!(f, "{}", cause),
GetAuthorizersError::NotFound(ref cause) => write!(f, "{}", cause),
GetAuthorizersError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAuthorizersError {}
#[derive(Debug, PartialEq)]
pub enum GetDeploymentError {
NotFound(String),
TooManyRequests(String),
}
impl GetDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(GetDeploymentError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetDeploymentError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeploymentError::NotFound(ref cause) => write!(f, "{}", cause),
GetDeploymentError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum GetDeploymentsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetDeploymentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDeploymentsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDeploymentsError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDeploymentsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetDeploymentsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDeploymentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDeploymentsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDeploymentsError::NotFound(ref cause) => write!(f, "{}", cause),
GetDeploymentsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDeploymentsError {}
#[derive(Debug, PartialEq)]
pub enum GetDomainNameError {
NotFound(String),
TooManyRequests(String),
}
impl GetDomainNameError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDomainNameError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(GetDomainNameError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetDomainNameError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDomainNameError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDomainNameError::NotFound(ref cause) => write!(f, "{}", cause),
GetDomainNameError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDomainNameError {}
#[derive(Debug, PartialEq)]
pub enum GetDomainNamesError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetDomainNamesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDomainNamesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDomainNamesError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDomainNamesError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetDomainNamesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDomainNamesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDomainNamesError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDomainNamesError::NotFound(ref cause) => write!(f, "{}", cause),
GetDomainNamesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDomainNamesError {}
#[derive(Debug, PartialEq)]
pub enum GetIntegrationError {
NotFound(String),
TooManyRequests(String),
}
impl GetIntegrationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetIntegrationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(GetIntegrationError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetIntegrationError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetIntegrationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetIntegrationError::NotFound(ref cause) => write!(f, "{}", cause),
GetIntegrationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetIntegrationError {}
#[derive(Debug, PartialEq)]
pub enum GetIntegrationResponseError {
NotFound(String),
TooManyRequests(String),
}
impl GetIntegrationResponseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetIntegrationResponseError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(GetIntegrationResponseError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetIntegrationResponseError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetIntegrationResponseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetIntegrationResponseError::NotFound(ref cause) => write!(f, "{}", cause),
GetIntegrationResponseError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetIntegrationResponseError {}
#[derive(Debug, PartialEq)]
pub enum GetIntegrationResponsesError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetIntegrationResponsesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetIntegrationResponsesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetIntegrationResponsesError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetIntegrationResponsesError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetIntegrationResponsesError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetIntegrationResponsesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetIntegrationResponsesError::BadRequest(ref cause) => write!(f, "{}", cause),
GetIntegrationResponsesError::NotFound(ref cause) => write!(f, "{}", cause),
GetIntegrationResponsesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetIntegrationResponsesError {}
#[derive(Debug, PartialEq)]
pub enum GetIntegrationsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetIntegrationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetIntegrationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetIntegrationsError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetIntegrationsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetIntegrationsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetIntegrationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetIntegrationsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetIntegrationsError::NotFound(ref cause) => write!(f, "{}", cause),
GetIntegrationsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetIntegrationsError {}
#[derive(Debug, PartialEq)]
pub enum GetModelError {
NotFound(String),
TooManyRequests(String),
}
impl GetModelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetModelError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(GetModelError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetModelError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetModelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetModelError::NotFound(ref cause) => write!(f, "{}", cause),
GetModelError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetModelError {}
#[derive(Debug, PartialEq)]
pub enum GetModelTemplateError {
NotFound(String),
TooManyRequests(String),
}
impl GetModelTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetModelTemplateError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(GetModelTemplateError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetModelTemplateError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetModelTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetModelTemplateError::NotFound(ref cause) => write!(f, "{}", cause),
GetModelTemplateError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetModelTemplateError {}
#[derive(Debug, PartialEq)]
pub enum GetModelsError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetModelsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetModelsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetModelsError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetModelsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetModelsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetModelsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetModelsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetModelsError::NotFound(ref cause) => write!(f, "{}", cause),
GetModelsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetModelsError {}
#[derive(Debug, PartialEq)]
pub enum GetRouteError {
NotFound(String),
TooManyRequests(String),
}
impl GetRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetRouteError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(GetRouteError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetRouteError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRouteError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRouteError::NotFound(ref cause) => write!(f, "{}", cause),
GetRouteError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRouteError {}
#[derive(Debug, PartialEq)]
pub enum GetRouteResponseError {
NotFound(String),
TooManyRequests(String),
}
impl GetRouteResponseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetRouteResponseError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(GetRouteResponseError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetRouteResponseError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRouteResponseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRouteResponseError::NotFound(ref cause) => write!(f, "{}", cause),
GetRouteResponseError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRouteResponseError {}
#[derive(Debug, PartialEq)]
pub enum GetRouteResponsesError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetRouteResponsesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetRouteResponsesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetRouteResponsesError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetRouteResponsesError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetRouteResponsesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRouteResponsesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRouteResponsesError::BadRequest(ref cause) => write!(f, "{}", cause),
GetRouteResponsesError::NotFound(ref cause) => write!(f, "{}", cause),
GetRouteResponsesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRouteResponsesError {}
#[derive(Debug, PartialEq)]
pub enum GetRoutesError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetRoutesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetRoutesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetRoutesError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetRoutesError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetRoutesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRoutesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRoutesError::BadRequest(ref cause) => write!(f, "{}", cause),
GetRoutesError::NotFound(ref cause) => write!(f, "{}", cause),
GetRoutesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRoutesError {}
#[derive(Debug, PartialEq)]
pub enum GetStageError {
NotFound(String),
TooManyRequests(String),
}
impl GetStageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetStageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(GetStageError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetStageError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetStageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetStageError::NotFound(ref cause) => write!(f, "{}", cause),
GetStageError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetStageError {}
#[derive(Debug, PartialEq)]
pub enum GetStagesError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl GetStagesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetStagesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetStagesError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetStagesError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetStagesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetStagesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetStagesError::BadRequest(ref cause) => write!(f, "{}", cause),
GetStagesError::NotFound(ref cause) => write!(f, "{}", cause),
GetStagesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetStagesError {}
#[derive(Debug, PartialEq)]
pub enum GetTagsError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl GetTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetTagsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetTagsError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(GetTagsError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetTagsError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetTagsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTagsError::BadRequest(ref cause) => write!(f, "{}", cause),
GetTagsError::Conflict(ref cause) => write!(f, "{}", cause),
GetTagsError::NotFound(ref cause) => write!(f, "{}", cause),
GetTagsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetTagsError {}
#[derive(Debug, PartialEq)]
pub enum GetVpcLinkError {
NotFound(String),
TooManyRequests(String),
}
impl GetVpcLinkError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetVpcLinkError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"NotFoundException" => {
return RusotoError::Service(GetVpcLinkError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetVpcLinkError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetVpcLinkError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetVpcLinkError::NotFound(ref cause) => write!(f, "{}", cause),
GetVpcLinkError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetVpcLinkError {}
#[derive(Debug, PartialEq)]
pub enum GetVpcLinksError {
BadRequest(String),
TooManyRequests(String),
}
impl GetVpcLinksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetVpcLinksError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetVpcLinksError::BadRequest(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetVpcLinksError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetVpcLinksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetVpcLinksError::BadRequest(ref cause) => write!(f, "{}", cause),
GetVpcLinksError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetVpcLinksError {}
#[derive(Debug, PartialEq)]
pub enum ImportApiError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl ImportApiError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ImportApiError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ImportApiError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(ImportApiError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ImportApiError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ImportApiError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ImportApiError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ImportApiError::BadRequest(ref cause) => write!(f, "{}", cause),
ImportApiError::Conflict(ref cause) => write!(f, "{}", cause),
ImportApiError::NotFound(ref cause) => write!(f, "{}", cause),
ImportApiError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ImportApiError {}
#[derive(Debug, PartialEq)]
pub enum ReimportApiError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl ReimportApiError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ReimportApiError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ReimportApiError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(ReimportApiError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ReimportApiError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ReimportApiError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ReimportApiError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ReimportApiError::BadRequest(ref cause) => write!(f, "{}", cause),
ReimportApiError::Conflict(ref cause) => write!(f, "{}", cause),
ReimportApiError::NotFound(ref cause) => write!(f, "{}", cause),
ReimportApiError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ReimportApiError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(TagResourceError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(TagResourceError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(TagResourceError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(TagResourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::Conflict(ref cause) => write!(f, "{}", cause),
TagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UntagResourceError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UntagResourceError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UntagResourceError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UntagResourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::Conflict(ref cause) => write!(f, "{}", cause),
UntagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApiError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateApiError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateApiError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateApiError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateApiError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateApiError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateApiError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateApiError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateApiError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateApiError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateApiError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateApiError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateApiError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApiMappingError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateApiMappingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateApiMappingError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateApiMappingError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateApiMappingError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateApiMappingError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateApiMappingError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateApiMappingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateApiMappingError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateApiMappingError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateApiMappingError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateApiMappingError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateApiMappingError {}
#[derive(Debug, PartialEq)]
pub enum UpdateAuthorizerError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateAuthorizerError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateAuthorizerError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateAuthorizerError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateAuthorizerError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateAuthorizerError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateAuthorizerError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateAuthorizerError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateAuthorizerError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateAuthorizerError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateAuthorizerError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateAuthorizerError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateAuthorizerError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDeploymentError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateDeploymentError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateDeploymentError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateDeploymentError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateDeploymentError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDeploymentError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateDeploymentError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateDeploymentError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateDeploymentError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDomainNameError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateDomainNameError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDomainNameError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateDomainNameError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateDomainNameError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateDomainNameError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateDomainNameError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDomainNameError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDomainNameError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateDomainNameError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateDomainNameError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateDomainNameError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDomainNameError {}
#[derive(Debug, PartialEq)]
pub enum UpdateIntegrationError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateIntegrationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateIntegrationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateIntegrationError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateIntegrationError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateIntegrationError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateIntegrationError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateIntegrationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateIntegrationError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateIntegrationError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateIntegrationError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateIntegrationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateIntegrationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateIntegrationResponseError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateIntegrationResponseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateIntegrationResponseError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateIntegrationResponseError::BadRequest(
err.msg,
))
}
"ConflictException" => {
return RusotoError::Service(UpdateIntegrationResponseError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateIntegrationResponseError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateIntegrationResponseError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateIntegrationResponseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateIntegrationResponseError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateIntegrationResponseError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateIntegrationResponseError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateIntegrationResponseError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateIntegrationResponseError {}
#[derive(Debug, PartialEq)]
pub enum UpdateModelError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateModelError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateModelError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateModelError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateModelError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateModelError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateModelError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateModelError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateModelError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateModelError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateModelError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateModelError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateModelError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRouteError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateRouteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateRouteError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateRouteError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateRouteError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateRouteError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateRouteError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRouteError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRouteError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateRouteError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateRouteError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateRouteError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateRouteError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRouteResponseError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateRouteResponseError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateRouteResponseError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateRouteResponseError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateRouteResponseError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateRouteResponseError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateRouteResponseError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRouteResponseError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRouteResponseError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateRouteResponseError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateRouteResponseError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateRouteResponseError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateRouteResponseError {}
#[derive(Debug, PartialEq)]
pub enum UpdateStageError {
BadRequest(String),
Conflict(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateStageError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateStageError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateStageError::BadRequest(err.msg))
}
"ConflictException" => {
return RusotoError::Service(UpdateStageError::Conflict(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateStageError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateStageError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateStageError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateStageError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateStageError::Conflict(ref cause) => write!(f, "{}", cause),
UpdateStageError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateStageError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateStageError {}
#[derive(Debug, PartialEq)]
pub enum UpdateVpcLinkError {
BadRequest(String),
NotFound(String),
TooManyRequests(String),
}
impl UpdateVpcLinkError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateVpcLinkError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateVpcLinkError::BadRequest(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateVpcLinkError::NotFound(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateVpcLinkError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateVpcLinkError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateVpcLinkError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateVpcLinkError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateVpcLinkError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateVpcLinkError {}
#[async_trait]
pub trait ApiGatewayV2 {
async fn create_api(
&self,
input: CreateApiRequest,
) -> Result<CreateApiResponse, RusotoError<CreateApiError>>;
async fn create_api_mapping(
&self,
input: CreateApiMappingRequest,
) -> Result<CreateApiMappingResponse, RusotoError<CreateApiMappingError>>;
async fn create_authorizer(
&self,
input: CreateAuthorizerRequest,
) -> Result<CreateAuthorizerResponse, RusotoError<CreateAuthorizerError>>;
async fn create_deployment(
&self,
input: CreateDeploymentRequest,
) -> Result<CreateDeploymentResponse, RusotoError<CreateDeploymentError>>;
async fn create_domain_name(
&self,
input: CreateDomainNameRequest,
) -> Result<CreateDomainNameResponse, RusotoError<CreateDomainNameError>>;
async fn create_integration(
&self,
input: CreateIntegrationRequest,
) -> Result<CreateIntegrationResult, RusotoError<CreateIntegrationError>>;
async fn create_integration_response(
&self,
input: CreateIntegrationResponseRequest,
) -> Result<CreateIntegrationResponseResponse, RusotoError<CreateIntegrationResponseError>>;
async fn create_model(
&self,
input: CreateModelRequest,
) -> Result<CreateModelResponse, RusotoError<CreateModelError>>;
async fn create_route(
&self,
input: CreateRouteRequest,
) -> Result<CreateRouteResult, RusotoError<CreateRouteError>>;
async fn create_route_response(
&self,
input: CreateRouteResponseRequest,
) -> Result<CreateRouteResponseResponse, RusotoError<CreateRouteResponseError>>;
async fn create_stage(
&self,
input: CreateStageRequest,
) -> Result<CreateStageResponse, RusotoError<CreateStageError>>;
async fn create_vpc_link(
&self,
input: CreateVpcLinkRequest,
) -> Result<CreateVpcLinkResponse, RusotoError<CreateVpcLinkError>>;
async fn delete_access_log_settings(
&self,
input: DeleteAccessLogSettingsRequest,
) -> Result<(), RusotoError<DeleteAccessLogSettingsError>>;
async fn delete_api(&self, input: DeleteApiRequest) -> Result<(), RusotoError<DeleteApiError>>;
async fn delete_api_mapping(
&self,
input: DeleteApiMappingRequest,
) -> Result<(), RusotoError<DeleteApiMappingError>>;
async fn delete_authorizer(
&self,
input: DeleteAuthorizerRequest,
) -> Result<(), RusotoError<DeleteAuthorizerError>>;
async fn delete_cors_configuration(
&self,
input: DeleteCorsConfigurationRequest,
) -> Result<(), RusotoError<DeleteCorsConfigurationError>>;
async fn delete_deployment(
&self,
input: DeleteDeploymentRequest,
) -> Result<(), RusotoError<DeleteDeploymentError>>;
async fn delete_domain_name(
&self,
input: DeleteDomainNameRequest,
) -> Result<(), RusotoError<DeleteDomainNameError>>;
async fn delete_integration(
&self,
input: DeleteIntegrationRequest,
) -> Result<(), RusotoError<DeleteIntegrationError>>;
async fn delete_integration_response(
&self,
input: DeleteIntegrationResponseRequest,
) -> Result<(), RusotoError<DeleteIntegrationResponseError>>;
async fn delete_model(
&self,
input: DeleteModelRequest,
) -> Result<(), RusotoError<DeleteModelError>>;
async fn delete_route(
&self,
input: DeleteRouteRequest,
) -> Result<(), RusotoError<DeleteRouteError>>;
async fn delete_route_request_parameter(
&self,
input: DeleteRouteRequestParameterRequest,
) -> Result<(), RusotoError<DeleteRouteRequestParameterError>>;
async fn delete_route_response(
&self,
input: DeleteRouteResponseRequest,
) -> Result<(), RusotoError<DeleteRouteResponseError>>;
async fn delete_route_settings(
&self,
input: DeleteRouteSettingsRequest,
) -> Result<(), RusotoError<DeleteRouteSettingsError>>;
async fn delete_stage(
&self,
input: DeleteStageRequest,
) -> Result<(), RusotoError<DeleteStageError>>;
async fn delete_vpc_link(
&self,
input: DeleteVpcLinkRequest,
) -> Result<DeleteVpcLinkResponse, RusotoError<DeleteVpcLinkError>>;
async fn export_api(
&self,
input: ExportApiRequest,
) -> Result<ExportApiResponse, RusotoError<ExportApiError>>;
async fn get_api(
&self,
input: GetApiRequest,
) -> Result<GetApiResponse, RusotoError<GetApiError>>;
async fn get_api_mapping(
&self,
input: GetApiMappingRequest,
) -> Result<GetApiMappingResponse, RusotoError<GetApiMappingError>>;
async fn get_api_mappings(
&self,
input: GetApiMappingsRequest,
) -> Result<GetApiMappingsResponse, RusotoError<GetApiMappingsError>>;
async fn get_apis(
&self,
input: GetApisRequest,
) -> Result<GetApisResponse, RusotoError<GetApisError>>;
async fn get_authorizer(
&self,
input: GetAuthorizerRequest,
) -> Result<GetAuthorizerResponse, RusotoError<GetAuthorizerError>>;
async fn get_authorizers(
&self,
input: GetAuthorizersRequest,
) -> Result<GetAuthorizersResponse, RusotoError<GetAuthorizersError>>;
async fn get_deployment(
&self,
input: GetDeploymentRequest,
) -> Result<GetDeploymentResponse, RusotoError<GetDeploymentError>>;
async fn get_deployments(
&self,
input: GetDeploymentsRequest,
) -> Result<GetDeploymentsResponse, RusotoError<GetDeploymentsError>>;
async fn get_domain_name(
&self,
input: GetDomainNameRequest,
) -> Result<GetDomainNameResponse, RusotoError<GetDomainNameError>>;
async fn get_domain_names(
&self,
input: GetDomainNamesRequest,
) -> Result<GetDomainNamesResponse, RusotoError<GetDomainNamesError>>;
async fn get_integration(
&self,
input: GetIntegrationRequest,
) -> Result<GetIntegrationResult, RusotoError<GetIntegrationError>>;
async fn get_integration_response(
&self,
input: GetIntegrationResponseRequest,
) -> Result<GetIntegrationResponseResponse, RusotoError<GetIntegrationResponseError>>;
async fn get_integration_responses(
&self,
input: GetIntegrationResponsesRequest,
) -> Result<GetIntegrationResponsesResponse, RusotoError<GetIntegrationResponsesError>>;
async fn get_integrations(
&self,
input: GetIntegrationsRequest,
) -> Result<GetIntegrationsResponse, RusotoError<GetIntegrationsError>>;
async fn get_model(
&self,
input: GetModelRequest,
) -> Result<GetModelResponse, RusotoError<GetModelError>>;
async fn get_model_template(
&self,
input: GetModelTemplateRequest,
) -> Result<GetModelTemplateResponse, RusotoError<GetModelTemplateError>>;
async fn get_models(
&self,
input: GetModelsRequest,
) -> Result<GetModelsResponse, RusotoError<GetModelsError>>;
async fn get_route(
&self,
input: GetRouteRequest,
) -> Result<GetRouteResult, RusotoError<GetRouteError>>;
async fn get_route_response(
&self,
input: GetRouteResponseRequest,
) -> Result<GetRouteResponseResponse, RusotoError<GetRouteResponseError>>;
async fn get_route_responses(
&self,
input: GetRouteResponsesRequest,
) -> Result<GetRouteResponsesResponse, RusotoError<GetRouteResponsesError>>;
async fn get_routes(
&self,
input: GetRoutesRequest,
) -> Result<GetRoutesResponse, RusotoError<GetRoutesError>>;
async fn get_stage(
&self,
input: GetStageRequest,
) -> Result<GetStageResponse, RusotoError<GetStageError>>;
async fn get_stages(
&self,
input: GetStagesRequest,
) -> Result<GetStagesResponse, RusotoError<GetStagesError>>;
async fn get_tags(
&self,
input: GetTagsRequest,
) -> Result<GetTagsResponse, RusotoError<GetTagsError>>;
async fn get_vpc_link(
&self,
input: GetVpcLinkRequest,
) -> Result<GetVpcLinkResponse, RusotoError<GetVpcLinkError>>;
async fn get_vpc_links(
&self,
input: GetVpcLinksRequest,
) -> Result<GetVpcLinksResponse, RusotoError<GetVpcLinksError>>;
async fn import_api(
&self,
input: ImportApiRequest,
) -> Result<ImportApiResponse, RusotoError<ImportApiError>>;
async fn reimport_api(
&self,
input: ReimportApiRequest,
) -> Result<ReimportApiResponse, RusotoError<ReimportApiError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>>;
async fn update_api(
&self,
input: UpdateApiRequest,
) -> Result<UpdateApiResponse, RusotoError<UpdateApiError>>;
async fn update_api_mapping(
&self,
input: UpdateApiMappingRequest,
) -> Result<UpdateApiMappingResponse, RusotoError<UpdateApiMappingError>>;
async fn update_authorizer(
&self,
input: UpdateAuthorizerRequest,
) -> Result<UpdateAuthorizerResponse, RusotoError<UpdateAuthorizerError>>;
async fn update_deployment(
&self,
input: UpdateDeploymentRequest,
) -> Result<UpdateDeploymentResponse, RusotoError<UpdateDeploymentError>>;
async fn update_domain_name(
&self,
input: UpdateDomainNameRequest,
) -> Result<UpdateDomainNameResponse, RusotoError<UpdateDomainNameError>>;
async fn update_integration(
&self,
input: UpdateIntegrationRequest,
) -> Result<UpdateIntegrationResult, RusotoError<UpdateIntegrationError>>;
async fn update_integration_response(
&self,
input: UpdateIntegrationResponseRequest,
) -> Result<UpdateIntegrationResponseResponse, RusotoError<UpdateIntegrationResponseError>>;
async fn update_model(
&self,
input: UpdateModelRequest,
) -> Result<UpdateModelResponse, RusotoError<UpdateModelError>>;
async fn update_route(
&self,
input: UpdateRouteRequest,
) -> Result<UpdateRouteResult, RusotoError<UpdateRouteError>>;
async fn update_route_response(
&self,
input: UpdateRouteResponseRequest,
) -> Result<UpdateRouteResponseResponse, RusotoError<UpdateRouteResponseError>>;
async fn update_stage(
&self,
input: UpdateStageRequest,
) -> Result<UpdateStageResponse, RusotoError<UpdateStageError>>;
async fn update_vpc_link(
&self,
input: UpdateVpcLinkRequest,
) -> Result<UpdateVpcLinkResponse, RusotoError<UpdateVpcLinkError>>;
}
#[derive(Clone)]
pub struct ApiGatewayV2Client {
client: Client,
region: region::Region,
}
impl ApiGatewayV2Client {
pub fn new(region: region::Region) -> ApiGatewayV2Client {
ApiGatewayV2Client {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> ApiGatewayV2Client
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
ApiGatewayV2Client {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> ApiGatewayV2Client {
ApiGatewayV2Client { client, region }
}
}
#[async_trait]
impl ApiGatewayV2 for ApiGatewayV2Client {
#[allow(unused_mut)]
async fn create_api(
&self,
input: CreateApiRequest,
) -> Result<CreateApiResponse, RusotoError<CreateApiError>> {
let request_uri = "/v2/apis";
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateApiResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateApiError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_api_mapping(
&self,
input: CreateApiMappingRequest,
) -> Result<CreateApiMappingResponse, RusotoError<CreateApiMappingError>> {
let request_uri = format!(
"/v2/domainnames/{domain_name}/apimappings",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateApiMappingResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateApiMappingError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_authorizer(
&self,
input: CreateAuthorizerRequest,
) -> Result<CreateAuthorizerResponse, RusotoError<CreateAuthorizerError>> {
let request_uri = format!("/v2/apis/{api_id}/authorizers", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateAuthorizerResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateAuthorizerError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_deployment(
&self,
input: CreateDeploymentRequest,
) -> Result<CreateDeploymentResponse, RusotoError<CreateDeploymentError>> {
let request_uri = format!("/v2/apis/{api_id}/deployments", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDeploymentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_domain_name(
&self,
input: CreateDomainNameRequest,
) -> Result<CreateDomainNameResponse, RusotoError<CreateDomainNameError>> {
let request_uri = "/v2/domainnames";
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDomainNameResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDomainNameError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_integration(
&self,
input: CreateIntegrationRequest,
) -> Result<CreateIntegrationResult, RusotoError<CreateIntegrationError>> {
let request_uri = format!("/v2/apis/{api_id}/integrations", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateIntegrationResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateIntegrationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_integration_response(
&self,
input: CreateIntegrationResponseRequest,
) -> Result<CreateIntegrationResponseResponse, RusotoError<CreateIntegrationResponseError>>
{
let request_uri = format!(
"/v2/apis/{api_id}/integrations/{integration_id}/integrationresponses",
api_id = input.api_id,
integration_id = input.integration_id
);
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateIntegrationResponseResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateIntegrationResponseError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_model(
&self,
input: CreateModelRequest,
) -> Result<CreateModelResponse, RusotoError<CreateModelError>> {
let request_uri = format!("/v2/apis/{api_id}/models", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateModelResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateModelError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_route(
&self,
input: CreateRouteRequest,
) -> Result<CreateRouteResult, RusotoError<CreateRouteError>> {
let request_uri = format!("/v2/apis/{api_id}/routes", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateRouteResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateRouteError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_route_response(
&self,
input: CreateRouteResponseRequest,
) -> Result<CreateRouteResponseResponse, RusotoError<CreateRouteResponseError>> {
let request_uri = format!(
"/v2/apis/{api_id}/routes/{route_id}/routeresponses",
api_id = input.api_id,
route_id = input.route_id
);
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateRouteResponseResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateRouteResponseError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_stage(
&self,
input: CreateStageRequest,
) -> Result<CreateStageResponse, RusotoError<CreateStageError>> {
let request_uri = format!("/v2/apis/{api_id}/stages", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateStageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateStageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_vpc_link(
&self,
input: CreateVpcLinkRequest,
) -> Result<CreateVpcLinkResponse, RusotoError<CreateVpcLinkError>> {
let request_uri = "/v2/vpclinks";
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateVpcLinkResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateVpcLinkError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_access_log_settings(
&self,
input: DeleteAccessLogSettingsRequest,
) -> Result<(), RusotoError<DeleteAccessLogSettingsError>> {
let request_uri = format!(
"/v2/apis/{api_id}/stages/{stage_name}/accesslogsettings",
api_id = input.api_id,
stage_name = input.stage_name
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteAccessLogSettingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_api(&self, input: DeleteApiRequest) -> Result<(), RusotoError<DeleteApiError>> {
let request_uri = format!("/v2/apis/{api_id}", api_id = input.api_id);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApiError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_api_mapping(
&self,
input: DeleteApiMappingRequest,
) -> Result<(), RusotoError<DeleteApiMappingError>> {
let request_uri = format!(
"/v2/domainnames/{domain_name}/apimappings/{api_mapping_id}",
api_mapping_id = input.api_mapping_id,
domain_name = input.domain_name
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApiMappingError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_authorizer(
&self,
input: DeleteAuthorizerRequest,
) -> Result<(), RusotoError<DeleteAuthorizerError>> {
let request_uri = format!(
"/v2/apis/{api_id}/authorizers/{authorizer_id}",
api_id = input.api_id,
authorizer_id = input.authorizer_id
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteAuthorizerError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_cors_configuration(
&self,
input: DeleteCorsConfigurationRequest,
) -> Result<(), RusotoError<DeleteCorsConfigurationError>> {
let request_uri = format!("/v2/apis/{api_id}/cors", api_id = input.api_id);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteCorsConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_deployment(
&self,
input: DeleteDeploymentRequest,
) -> Result<(), RusotoError<DeleteDeploymentError>> {
let request_uri = format!(
"/v2/apis/{api_id}/deployments/{deployment_id}",
api_id = input.api_id,
deployment_id = input.deployment_id
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_domain_name(
&self,
input: DeleteDomainNameRequest,
) -> Result<(), RusotoError<DeleteDomainNameError>> {
let request_uri = format!(
"/v2/domainnames/{domain_name}",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDomainNameError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_integration(
&self,
input: DeleteIntegrationRequest,
) -> Result<(), RusotoError<DeleteIntegrationError>> {
let request_uri = format!(
"/v2/apis/{api_id}/integrations/{integration_id}",
api_id = input.api_id,
integration_id = input.integration_id
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteIntegrationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_integration_response(
&self,
input: DeleteIntegrationResponseRequest,
) -> Result<(), RusotoError<DeleteIntegrationResponseError>> {
let request_uri = format!("/v2/apis/{api_id}/integrations/{integration_id}/integrationresponses/{integration_response_id}", api_id = input.api_id, integration_id = input.integration_id, integration_response_id = input.integration_response_id);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteIntegrationResponseError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_model(
&self,
input: DeleteModelRequest,
) -> Result<(), RusotoError<DeleteModelError>> {
let request_uri = format!(
"/v2/apis/{api_id}/models/{model_id}",
api_id = input.api_id,
model_id = input.model_id
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteModelError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_route(
&self,
input: DeleteRouteRequest,
) -> Result<(), RusotoError<DeleteRouteError>> {
let request_uri = format!(
"/v2/apis/{api_id}/routes/{route_id}",
api_id = input.api_id,
route_id = input.route_id
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteRouteError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_route_request_parameter(
&self,
input: DeleteRouteRequestParameterRequest,
) -> Result<(), RusotoError<DeleteRouteRequestParameterError>> {
let request_uri = format!(
"/v2/apis/{api_id}/routes/{route_id}/requestparameters/{request_parameter_key}",
api_id = input.api_id,
request_parameter_key = input.request_parameter_key,
route_id = input.route_id
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteRouteRequestParameterError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_route_response(
&self,
input: DeleteRouteResponseRequest,
) -> Result<(), RusotoError<DeleteRouteResponseError>> {
let request_uri = format!(
"/v2/apis/{api_id}/routes/{route_id}/routeresponses/{route_response_id}",
api_id = input.api_id,
route_id = input.route_id,
route_response_id = input.route_response_id
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteRouteResponseError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_route_settings(
&self,
input: DeleteRouteSettingsRequest,
) -> Result<(), RusotoError<DeleteRouteSettingsError>> {
let request_uri = format!(
"/v2/apis/{api_id}/stages/{stage_name}/routesettings/{route_key}",
api_id = input.api_id,
route_key = input.route_key,
stage_name = input.stage_name
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteRouteSettingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_stage(
&self,
input: DeleteStageRequest,
) -> Result<(), RusotoError<DeleteStageError>> {
let request_uri = format!(
"/v2/apis/{api_id}/stages/{stage_name}",
api_id = input.api_id,
stage_name = input.stage_name
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteStageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_vpc_link(
&self,
input: DeleteVpcLinkRequest,
) -> Result<DeleteVpcLinkResponse, RusotoError<DeleteVpcLinkError>> {
let request_uri = format!(
"/v2/vpclinks/{vpc_link_id}",
vpc_link_id = input.vpc_link_id
);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteVpcLinkResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteVpcLinkError::from_response(response))
}
}
#[allow(unused_mut)]
async fn export_api(
&self,
input: ExportApiRequest,
) -> Result<ExportApiResponse, RusotoError<ExportApiError>> {
let request_uri = format!(
"/v2/apis/{api_id}/exports/{specification}",
api_id = input.api_id,
specification = input.specification
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.export_version {
params.put("exportVersion", x);
}
if let Some(ref x) = input.include_extensions {
params.put("includeExtensions", x);
}
params.put("outputType", &input.output_type);
if let Some(ref x) = input.stage_name {
params.put("stageName", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let mut result = ExportApiResponse::default();
result.body = Some(response.body);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ExportApiError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_api(
&self,
input: GetApiRequest,
) -> Result<GetApiResponse, RusotoError<GetApiError>> {
let request_uri = format!("/v2/apis/{api_id}", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<GetApiResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetApiError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_api_mapping(
&self,
input: GetApiMappingRequest,
) -> Result<GetApiMappingResponse, RusotoError<GetApiMappingError>> {
let request_uri = format!(
"/v2/domainnames/{domain_name}/apimappings/{api_mapping_id}",
api_mapping_id = input.api_mapping_id,
domain_name = input.domain_name
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetApiMappingResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetApiMappingError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_api_mappings(
&self,
input: GetApiMappingsRequest,
) -> Result<GetApiMappingsResponse, RusotoError<GetApiMappingsError>> {
let request_uri = format!(
"/v2/domainnames/{domain_name}/apimappings",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetApiMappingsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetApiMappingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_apis(
&self,
input: GetApisRequest,
) -> Result<GetApisResponse, RusotoError<GetApisError>> {
let request_uri = "/v2/apis";
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<GetApisResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetApisError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_authorizer(
&self,
input: GetAuthorizerRequest,
) -> Result<GetAuthorizerResponse, RusotoError<GetAuthorizerError>> {
let request_uri = format!(
"/v2/apis/{api_id}/authorizers/{authorizer_id}",
api_id = input.api_id,
authorizer_id = input.authorizer_id
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetAuthorizerResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetAuthorizerError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_authorizers(
&self,
input: GetAuthorizersRequest,
) -> Result<GetAuthorizersResponse, RusotoError<GetAuthorizersError>> {
let request_uri = format!("/v2/apis/{api_id}/authorizers", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetAuthorizersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetAuthorizersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_deployment(
&self,
input: GetDeploymentRequest,
) -> Result<GetDeploymentResponse, RusotoError<GetDeploymentError>> {
let request_uri = format!(
"/v2/apis/{api_id}/deployments/{deployment_id}",
api_id = input.api_id,
deployment_id = input.deployment_id
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDeploymentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_deployments(
&self,
input: GetDeploymentsRequest,
) -> Result<GetDeploymentsResponse, RusotoError<GetDeploymentsError>> {
let request_uri = format!("/v2/apis/{api_id}/deployments", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDeploymentsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDeploymentsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_domain_name(
&self,
input: GetDomainNameRequest,
) -> Result<GetDomainNameResponse, RusotoError<GetDomainNameError>> {
let request_uri = format!(
"/v2/domainnames/{domain_name}",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDomainNameResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDomainNameError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_domain_names(
&self,
input: GetDomainNamesRequest,
) -> Result<GetDomainNamesResponse, RusotoError<GetDomainNamesError>> {
let request_uri = "/v2/domainnames";
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDomainNamesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDomainNamesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_integration(
&self,
input: GetIntegrationRequest,
) -> Result<GetIntegrationResult, RusotoError<GetIntegrationError>> {
let request_uri = format!(
"/v2/apis/{api_id}/integrations/{integration_id}",
api_id = input.api_id,
integration_id = input.integration_id
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetIntegrationResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetIntegrationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_integration_response(
&self,
input: GetIntegrationResponseRequest,
) -> Result<GetIntegrationResponseResponse, RusotoError<GetIntegrationResponseError>> {
let request_uri = format!("/v2/apis/{api_id}/integrations/{integration_id}/integrationresponses/{integration_response_id}", api_id = input.api_id, integration_id = input.integration_id, integration_response_id = input.integration_response_id);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetIntegrationResponseResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetIntegrationResponseError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_integration_responses(
&self,
input: GetIntegrationResponsesRequest,
) -> Result<GetIntegrationResponsesResponse, RusotoError<GetIntegrationResponsesError>> {
let request_uri = format!(
"/v2/apis/{api_id}/integrations/{integration_id}/integrationresponses",
api_id = input.api_id,
integration_id = input.integration_id
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetIntegrationResponsesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetIntegrationResponsesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_integrations(
&self,
input: GetIntegrationsRequest,
) -> Result<GetIntegrationsResponse, RusotoError<GetIntegrationsError>> {
let request_uri = format!("/v2/apis/{api_id}/integrations", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetIntegrationsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetIntegrationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_model(
&self,
input: GetModelRequest,
) -> Result<GetModelResponse, RusotoError<GetModelError>> {
let request_uri = format!(
"/v2/apis/{api_id}/models/{model_id}",
api_id = input.api_id,
model_id = input.model_id
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetModelResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetModelError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_model_template(
&self,
input: GetModelTemplateRequest,
) -> Result<GetModelTemplateResponse, RusotoError<GetModelTemplateError>> {
let request_uri = format!(
"/v2/apis/{api_id}/models/{model_id}/template",
api_id = input.api_id,
model_id = input.model_id
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetModelTemplateResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetModelTemplateError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_models(
&self,
input: GetModelsRequest,
) -> Result<GetModelsResponse, RusotoError<GetModelsError>> {
let request_uri = format!("/v2/apis/{api_id}/models", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetModelsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetModelsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_route(
&self,
input: GetRouteRequest,
) -> Result<GetRouteResult, RusotoError<GetRouteError>> {
let request_uri = format!(
"/v2/apis/{api_id}/routes/{route_id}",
api_id = input.api_id,
route_id = input.route_id
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<GetRouteResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetRouteError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_route_response(
&self,
input: GetRouteResponseRequest,
) -> Result<GetRouteResponseResponse, RusotoError<GetRouteResponseError>> {
let request_uri = format!(
"/v2/apis/{api_id}/routes/{route_id}/routeresponses/{route_response_id}",
api_id = input.api_id,
route_id = input.route_id,
route_response_id = input.route_response_id
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetRouteResponseResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetRouteResponseError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_route_responses(
&self,
input: GetRouteResponsesRequest,
) -> Result<GetRouteResponsesResponse, RusotoError<GetRouteResponsesError>> {
let request_uri = format!(
"/v2/apis/{api_id}/routes/{route_id}/routeresponses",
api_id = input.api_id,
route_id = input.route_id
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetRouteResponsesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetRouteResponsesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_routes(
&self,
input: GetRoutesRequest,
) -> Result<GetRoutesResponse, RusotoError<GetRoutesError>> {
let request_uri = format!("/v2/apis/{api_id}/routes", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetRoutesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetRoutesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_stage(
&self,
input: GetStageRequest,
) -> Result<GetStageResponse, RusotoError<GetStageError>> {
let request_uri = format!(
"/v2/apis/{api_id}/stages/{stage_name}",
api_id = input.api_id,
stage_name = input.stage_name
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetStageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetStageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_stages(
&self,
input: GetStagesRequest,
) -> Result<GetStagesResponse, RusotoError<GetStagesError>> {
let request_uri = format!("/v2/apis/{api_id}/stages", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetStagesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetStagesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_tags(
&self,
input: GetTagsRequest,
) -> Result<GetTagsResponse, RusotoError<GetTagsError>> {
let request_uri = format!("/v2/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<GetTagsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetTagsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_vpc_link(
&self,
input: GetVpcLinkRequest,
) -> Result<GetVpcLinkResponse, RusotoError<GetVpcLinkError>> {
let request_uri = format!(
"/v2/vpclinks/{vpc_link_id}",
vpc_link_id = input.vpc_link_id
);
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetVpcLinkResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetVpcLinkError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_vpc_links(
&self,
input: GetVpcLinksRequest,
) -> Result<GetVpcLinksResponse, RusotoError<GetVpcLinksError>> {
let request_uri = "/v2/vpclinks";
let mut request = SignedRequest::new("GET", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetVpcLinksResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetVpcLinksError::from_response(response))
}
}
#[allow(unused_mut)]
async fn import_api(
&self,
input: ImportApiRequest,
) -> Result<ImportApiResponse, RusotoError<ImportApiError>> {
let request_uri = "/v2/apis";
let mut request = SignedRequest::new("PUT", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut params = Params::new();
if let Some(ref x) = input.basepath {
params.put("basepath", x);
}
if let Some(ref x) = input.fail_on_warnings {
params.put("failOnWarnings", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ImportApiResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ImportApiError::from_response(response))
}
}
#[allow(unused_mut)]
async fn reimport_api(
&self,
input: ReimportApiRequest,
) -> Result<ReimportApiResponse, RusotoError<ReimportApiError>> {
let request_uri = format!("/v2/apis/{api_id}", api_id = input.api_id);
let mut request = SignedRequest::new("PUT", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut params = Params::new();
if let Some(ref x) = input.basepath {
params.put("basepath", x);
}
if let Some(ref x) = input.fail_on_warnings {
params.put("failOnWarnings", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ReimportApiResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ReimportApiError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = format!("/v2/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<TagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>> {
let request_uri = format!("/v2/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_api(
&self,
input: UpdateApiRequest,
) -> Result<UpdateApiResponse, RusotoError<UpdateApiError>> {
let request_uri = format!("/v2/apis/{api_id}", api_id = input.api_id);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateApiResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateApiError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_api_mapping(
&self,
input: UpdateApiMappingRequest,
) -> Result<UpdateApiMappingResponse, RusotoError<UpdateApiMappingError>> {
let request_uri = format!(
"/v2/domainnames/{domain_name}/apimappings/{api_mapping_id}",
api_mapping_id = input.api_mapping_id,
domain_name = input.domain_name
);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateApiMappingResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateApiMappingError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_authorizer(
&self,
input: UpdateAuthorizerRequest,
) -> Result<UpdateAuthorizerResponse, RusotoError<UpdateAuthorizerError>> {
let request_uri = format!(
"/v2/apis/{api_id}/authorizers/{authorizer_id}",
api_id = input.api_id,
authorizer_id = input.authorizer_id
);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateAuthorizerResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateAuthorizerError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_deployment(
&self,
input: UpdateDeploymentRequest,
) -> Result<UpdateDeploymentResponse, RusotoError<UpdateDeploymentError>> {
let request_uri = format!(
"/v2/apis/{api_id}/deployments/{deployment_id}",
api_id = input.api_id,
deployment_id = input.deployment_id
);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateDeploymentResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_domain_name(
&self,
input: UpdateDomainNameRequest,
) -> Result<UpdateDomainNameResponse, RusotoError<UpdateDomainNameError>> {
let request_uri = format!(
"/v2/domainnames/{domain_name}",
domain_name = input.domain_name
);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateDomainNameResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDomainNameError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_integration(
&self,
input: UpdateIntegrationRequest,
) -> Result<UpdateIntegrationResult, RusotoError<UpdateIntegrationError>> {
let request_uri = format!(
"/v2/apis/{api_id}/integrations/{integration_id}",
api_id = input.api_id,
integration_id = input.integration_id
);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateIntegrationResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateIntegrationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_integration_response(
&self,
input: UpdateIntegrationResponseRequest,
) -> Result<UpdateIntegrationResponseResponse, RusotoError<UpdateIntegrationResponseError>>
{
let request_uri = format!("/v2/apis/{api_id}/integrations/{integration_id}/integrationresponses/{integration_response_id}", api_id = input.api_id, integration_id = input.integration_id, integration_response_id = input.integration_response_id);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateIntegrationResponseResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateIntegrationResponseError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_model(
&self,
input: UpdateModelRequest,
) -> Result<UpdateModelResponse, RusotoError<UpdateModelError>> {
let request_uri = format!(
"/v2/apis/{api_id}/models/{model_id}",
api_id = input.api_id,
model_id = input.model_id
);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateModelResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateModelError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_route(
&self,
input: UpdateRouteRequest,
) -> Result<UpdateRouteResult, RusotoError<UpdateRouteError>> {
let request_uri = format!(
"/v2/apis/{api_id}/routes/{route_id}",
api_id = input.api_id,
route_id = input.route_id
);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateRouteResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateRouteError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_route_response(
&self,
input: UpdateRouteResponseRequest,
) -> Result<UpdateRouteResponseResponse, RusotoError<UpdateRouteResponseError>> {
let request_uri = format!(
"/v2/apis/{api_id}/routes/{route_id}/routeresponses/{route_response_id}",
api_id = input.api_id,
route_id = input.route_id,
route_response_id = input.route_response_id
);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateRouteResponseResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateRouteResponseError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_stage(
&self,
input: UpdateStageRequest,
) -> Result<UpdateStageResponse, RusotoError<UpdateStageError>> {
let request_uri = format!(
"/v2/apis/{api_id}/stages/{stage_name}",
api_id = input.api_id,
stage_name = input.stage_name
);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateStageResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateStageError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_vpc_link(
&self,
input: UpdateVpcLinkRequest,
) -> Result<UpdateVpcLinkResponse, RusotoError<UpdateVpcLinkError>> {
let request_uri = format!(
"/v2/vpclinks/{vpc_link_id}",
vpc_link_id = input.vpc_link_id
);
let mut request = SignedRequest::new("PATCH", "apigateway", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateVpcLinkResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateVpcLinkError::from_response(response))
}
}
}