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 AdditionalAuthenticationProvider {
#[serde(rename = "authenticationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_type: Option<String>,
#[serde(rename = "openIDConnectConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub open_id_connect_config: Option<OpenIDConnectConfig>,
#[serde(rename = "userPoolConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_config: Option<CognitoUserPoolConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApiCache {
#[serde(rename = "apiCachingBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_caching_behavior: Option<String>,
#[serde(rename = "atRestEncryptionEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub at_rest_encryption_enabled: Option<bool>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "transitEncryptionEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transit_encryption_enabled: Option<bool>,
#[serde(rename = "ttl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ttl: Option<i64>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApiKey {
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "expires")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expires: Option<i64>,
#[serde(rename = "id")]
#[serde(skip_serializing_if = "Option::is_none")]
pub id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AuthorizationConfig {
#[serde(rename = "authorizationType")]
pub authorization_type: String,
#[serde(rename = "awsIamConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_iam_config: Option<AwsIamConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AwsIamConfig {
#[serde(rename = "signingRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_region: Option<String>,
#[serde(rename = "signingServiceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_service_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CachingConfig {
#[serde(rename = "cachingKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caching_keys: Option<Vec<String>>,
#[serde(rename = "ttl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ttl: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CognitoUserPoolConfig {
#[serde(rename = "appIdClientRegex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id_client_regex: Option<String>,
#[serde(rename = "awsRegion")]
pub aws_region: String,
#[serde(rename = "userPoolId")]
pub user_pool_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApiCacheRequest {
#[serde(rename = "apiCachingBehavior")]
pub api_caching_behavior: String,
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "atRestEncryptionEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub at_rest_encryption_enabled: Option<bool>,
#[serde(rename = "transitEncryptionEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub transit_encryption_enabled: Option<bool>,
#[serde(rename = "ttl")]
pub ttl: i64,
#[serde(rename = "type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateApiCacheResponse {
#[serde(rename = "apiCache")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_cache: Option<ApiCache>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApiKeyRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "expires")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expires: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateApiKeyResponse {
#[serde(rename = "apiKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key: Option<ApiKey>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDataSourceRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "dynamodbConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamodb_config: Option<DynamodbDataSourceConfig>,
#[serde(rename = "elasticsearchConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_config: Option<ElasticsearchDataSourceConfig>,
#[serde(rename = "httpConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub http_config: Option<HttpDataSourceConfig>,
#[serde(rename = "lambdaConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_config: Option<LambdaDataSourceConfig>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "relationalDatabaseConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_config: Option<RelationalDatabaseDataSourceConfig>,
#[serde(rename = "serviceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_role_arn: Option<String>,
#[serde(rename = "type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDataSourceResponse {
#[serde(rename = "dataSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source: Option<DataSource>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFunctionRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "dataSourceName")]
pub data_source_name: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "functionVersion")]
pub function_version: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "requestMappingTemplate")]
pub request_mapping_template: String,
#[serde(rename = "responseMappingTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_mapping_template: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFunctionResponse {
#[serde(rename = "functionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_configuration: Option<FunctionConfiguration>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateGraphqlApiRequest {
#[serde(rename = "additionalAuthenticationProviders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_authentication_providers: Option<Vec<AdditionalAuthenticationProvider>>,
#[serde(rename = "authenticationType")]
pub authentication_type: String,
#[serde(rename = "logConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_config: Option<LogConfig>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "openIDConnectConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub open_id_connect_config: Option<OpenIDConnectConfig>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "userPoolConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_config: Option<UserPoolConfig>,
#[serde(rename = "xrayEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub xray_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateGraphqlApiResponse {
#[serde(rename = "graphqlApi")]
#[serde(skip_serializing_if = "Option::is_none")]
pub graphql_api: Option<GraphqlApi>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateResolverRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "cachingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caching_config: Option<CachingConfig>,
#[serde(rename = "dataSourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_name: Option<String>,
#[serde(rename = "fieldName")]
pub field_name: String,
#[serde(rename = "kind")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kind: Option<String>,
#[serde(rename = "pipelineConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pipeline_config: Option<PipelineConfig>,
#[serde(rename = "requestMappingTemplate")]
pub request_mapping_template: String,
#[serde(rename = "responseMappingTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_mapping_template: Option<String>,
#[serde(rename = "syncConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_config: Option<SyncConfig>,
#[serde(rename = "typeName")]
pub type_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateResolverResponse {
#[serde(rename = "resolver")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver: Option<Resolver>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTypeRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "definition")]
pub definition: String,
#[serde(rename = "format")]
pub format: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTypeResponse {
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<Type>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DataSource {
#[serde(rename = "dataSourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_arn: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "dynamodbConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamodb_config: Option<DynamodbDataSourceConfig>,
#[serde(rename = "elasticsearchConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_config: Option<ElasticsearchDataSourceConfig>,
#[serde(rename = "httpConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub http_config: Option<HttpDataSourceConfig>,
#[serde(rename = "lambdaConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_config: Option<LambdaDataSourceConfig>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "relationalDatabaseConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_config: Option<RelationalDatabaseDataSourceConfig>,
#[serde(rename = "serviceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_role_arn: Option<String>,
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApiCacheRequest {
#[serde(rename = "apiId")]
pub api_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApiCacheResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApiKeyRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApiKeyResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDataSourceRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDataSourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFunctionRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "functionId")]
pub function_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteFunctionResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteGraphqlApiRequest {
#[serde(rename = "apiId")]
pub api_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteGraphqlApiResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteResolverRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "fieldName")]
pub field_name: String,
#[serde(rename = "typeName")]
pub type_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteResolverResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTypeRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "typeName")]
pub type_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTypeResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeltaSyncConfig {
#[serde(rename = "baseTableTTL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_table_ttl: Option<i64>,
#[serde(rename = "deltaSyncTableName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delta_sync_table_name: Option<String>,
#[serde(rename = "deltaSyncTableTTL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delta_sync_table_ttl: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DynamodbDataSourceConfig {
#[serde(rename = "awsRegion")]
pub aws_region: String,
#[serde(rename = "deltaSyncConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delta_sync_config: Option<DeltaSyncConfig>,
#[serde(rename = "tableName")]
pub table_name: String,
#[serde(rename = "useCallerCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub use_caller_credentials: Option<bool>,
#[serde(rename = "versioned")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versioned: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ElasticsearchDataSourceConfig {
#[serde(rename = "awsRegion")]
pub aws_region: String,
#[serde(rename = "endpoint")]
pub endpoint: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FlushApiCacheRequest {
#[serde(rename = "apiId")]
pub api_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FlushApiCacheResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FunctionConfiguration {
#[serde(rename = "dataSourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_name: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "functionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_arn: Option<String>,
#[serde(rename = "functionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_id: Option<String>,
#[serde(rename = "functionVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_version: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "requestMappingTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_mapping_template: Option<String>,
#[serde(rename = "responseMappingTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_mapping_template: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetApiCacheRequest {
#[serde(rename = "apiId")]
pub api_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetApiCacheResponse {
#[serde(rename = "apiCache")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_cache: Option<ApiCache>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDataSourceRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDataSourceResponse {
#[serde(rename = "dataSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source: Option<DataSource>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFunctionRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "functionId")]
pub function_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFunctionResponse {
#[serde(rename = "functionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_configuration: Option<FunctionConfiguration>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetGraphqlApiRequest {
#[serde(rename = "apiId")]
pub api_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetGraphqlApiResponse {
#[serde(rename = "graphqlApi")]
#[serde(skip_serializing_if = "Option::is_none")]
pub graphql_api: Option<GraphqlApi>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetIntrospectionSchemaRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "format")]
pub format: String,
#[serde(rename = "includeDirectives")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_directives: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct GetIntrospectionSchemaResponse {
pub schema: Option<bytes::Bytes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetResolverRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "fieldName")]
pub field_name: String,
#[serde(rename = "typeName")]
pub type_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetResolverResponse {
#[serde(rename = "resolver")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver: Option<Resolver>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSchemaCreationStatusRequest {
#[serde(rename = "apiId")]
pub api_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSchemaCreationStatusResponse {
#[serde(rename = "details")]
#[serde(skip_serializing_if = "Option::is_none")]
pub details: Option<String>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTypeRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "format")]
pub format: String,
#[serde(rename = "typeName")]
pub type_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetTypeResponse {
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<Type>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GraphqlApi {
#[serde(rename = "additionalAuthenticationProviders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_authentication_providers: Option<Vec<AdditionalAuthenticationProvider>>,
#[serde(rename = "apiId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_id: Option<String>,
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "authenticationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_type: Option<String>,
#[serde(rename = "logConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_config: Option<LogConfig>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "openIDConnectConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub open_id_connect_config: Option<OpenIDConnectConfig>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "uris")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uris: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "userPoolConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_config: Option<UserPoolConfig>,
#[serde(rename = "xrayEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub xray_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct HttpDataSourceConfig {
#[serde(rename = "authorizationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authorization_config: Option<AuthorizationConfig>,
#[serde(rename = "endpoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoint: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LambdaConflictHandlerConfig {
#[serde(rename = "lambdaConflictHandlerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_conflict_handler_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LambdaDataSourceConfig {
#[serde(rename = "lambdaFunctionArn")]
pub lambda_function_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListApiKeysRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListApiKeysResponse {
#[serde(rename = "apiKeys")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_keys: Option<Vec<ApiKey>>,
#[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 ListDataSourcesRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDataSourcesResponse {
#[serde(rename = "dataSources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_sources: Option<Vec<DataSource>>,
#[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 ListFunctionsRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFunctionsResponse {
#[serde(rename = "functions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub functions: Option<Vec<FunctionConfiguration>>,
#[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 ListGraphqlApisRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListGraphqlApisResponse {
#[serde(rename = "graphqlApis")]
#[serde(skip_serializing_if = "Option::is_none")]
pub graphql_apis: Option<Vec<GraphqlApi>>,
#[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 ListResolversByFunctionRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "functionId")]
pub function_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResolversByFunctionResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resolvers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolvers: Option<Vec<Resolver>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListResolversRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "typeName")]
pub type_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListResolversResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resolvers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolvers: Option<Vec<Resolver>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTypesRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "format")]
pub format: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTypesResponse {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "types")]
#[serde(skip_serializing_if = "Option::is_none")]
pub types: Option<Vec<Type>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct LogConfig {
#[serde(rename = "cloudWatchLogsRoleArn")]
pub cloud_watch_logs_role_arn: String,
#[serde(rename = "excludeVerboseContent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exclude_verbose_content: Option<bool>,
#[serde(rename = "fieldLogLevel")]
pub field_log_level: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OpenIDConnectConfig {
#[serde(rename = "authTTL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auth_ttl: Option<i64>,
#[serde(rename = "clientId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_id: Option<String>,
#[serde(rename = "iatTTL")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iat_ttl: Option<i64>,
#[serde(rename = "issuer")]
pub issuer: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct PipelineConfig {
#[serde(rename = "functions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub functions: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RdsHttpEndpointConfig {
#[serde(rename = "awsRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_region: Option<String>,
#[serde(rename = "awsSecretStoreArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aws_secret_store_arn: Option<String>,
#[serde(rename = "databaseName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub database_name: Option<String>,
#[serde(rename = "dbClusterIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub db_cluster_identifier: Option<String>,
#[serde(rename = "schema")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RelationalDatabaseDataSourceConfig {
#[serde(rename = "rdsHttpEndpointConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rds_http_endpoint_config: Option<RdsHttpEndpointConfig>,
#[serde(rename = "relationalDatabaseSourceType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_source_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Resolver {
#[serde(rename = "cachingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caching_config: Option<CachingConfig>,
#[serde(rename = "dataSourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_name: Option<String>,
#[serde(rename = "fieldName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub field_name: Option<String>,
#[serde(rename = "kind")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kind: Option<String>,
#[serde(rename = "pipelineConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pipeline_config: Option<PipelineConfig>,
#[serde(rename = "requestMappingTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub request_mapping_template: Option<String>,
#[serde(rename = "resolverArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver_arn: Option<String>,
#[serde(rename = "responseMappingTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_mapping_template: Option<String>,
#[serde(rename = "syncConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_config: Option<SyncConfig>,
#[serde(rename = "typeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartSchemaCreationRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "definition")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub definition: bytes::Bytes,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartSchemaCreationResponse {
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SyncConfig {
#[serde(rename = "conflictDetection")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_detection: Option<String>,
#[serde(rename = "conflictHandler")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_handler: Option<String>,
#[serde(rename = "lambdaConflictHandlerConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_conflict_handler_config: Option<LambdaConflictHandlerConfig>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tags")]
pub tags: ::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 Type {
#[serde(rename = "arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "format")]
#[serde(skip_serializing_if = "Option::is_none")]
pub format: Option<String>,
#[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 UntagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApiCacheRequest {
#[serde(rename = "apiCachingBehavior")]
pub api_caching_behavior: String,
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "ttl")]
pub ttl: i64,
#[serde(rename = "type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateApiCacheResponse {
#[serde(rename = "apiCache")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_cache: Option<ApiCache>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApiKeyRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "expires")]
#[serde(skip_serializing_if = "Option::is_none")]
pub expires: Option<i64>,
#[serde(rename = "id")]
pub id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateApiKeyResponse {
#[serde(rename = "apiKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub api_key: Option<ApiKey>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDataSourceRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "dynamodbConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dynamodb_config: Option<DynamodbDataSourceConfig>,
#[serde(rename = "elasticsearchConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub elasticsearch_config: Option<ElasticsearchDataSourceConfig>,
#[serde(rename = "httpConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub http_config: Option<HttpDataSourceConfig>,
#[serde(rename = "lambdaConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lambda_config: Option<LambdaDataSourceConfig>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "relationalDatabaseConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relational_database_config: Option<RelationalDatabaseDataSourceConfig>,
#[serde(rename = "serviceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub service_role_arn: Option<String>,
#[serde(rename = "type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDataSourceResponse {
#[serde(rename = "dataSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source: Option<DataSource>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFunctionRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "dataSourceName")]
pub data_source_name: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "functionId")]
pub function_id: String,
#[serde(rename = "functionVersion")]
pub function_version: String,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "requestMappingTemplate")]
pub request_mapping_template: String,
#[serde(rename = "responseMappingTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_mapping_template: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateFunctionResponse {
#[serde(rename = "functionConfiguration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_configuration: Option<FunctionConfiguration>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateGraphqlApiRequest {
#[serde(rename = "additionalAuthenticationProviders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_authentication_providers: Option<Vec<AdditionalAuthenticationProvider>>,
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "authenticationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub authentication_type: Option<String>,
#[serde(rename = "logConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_config: Option<LogConfig>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "openIDConnectConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub open_id_connect_config: Option<OpenIDConnectConfig>,
#[serde(rename = "userPoolConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_pool_config: Option<UserPoolConfig>,
#[serde(rename = "xrayEnabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub xray_enabled: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateGraphqlApiResponse {
#[serde(rename = "graphqlApi")]
#[serde(skip_serializing_if = "Option::is_none")]
pub graphql_api: Option<GraphqlApi>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateResolverRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "cachingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caching_config: Option<CachingConfig>,
#[serde(rename = "dataSourceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub data_source_name: Option<String>,
#[serde(rename = "fieldName")]
pub field_name: String,
#[serde(rename = "kind")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kind: Option<String>,
#[serde(rename = "pipelineConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pipeline_config: Option<PipelineConfig>,
#[serde(rename = "requestMappingTemplate")]
pub request_mapping_template: String,
#[serde(rename = "responseMappingTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub response_mapping_template: Option<String>,
#[serde(rename = "syncConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sync_config: Option<SyncConfig>,
#[serde(rename = "typeName")]
pub type_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateResolverResponse {
#[serde(rename = "resolver")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolver: Option<Resolver>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateTypeRequest {
#[serde(rename = "apiId")]
pub api_id: String,
#[serde(rename = "definition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub definition: Option<String>,
#[serde(rename = "format")]
pub format: String,
#[serde(rename = "typeName")]
pub type_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateTypeResponse {
#[serde(rename = "type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<Type>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct UserPoolConfig {
#[serde(rename = "appIdClientRegex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub app_id_client_regex: Option<String>,
#[serde(rename = "awsRegion")]
pub aws_region: String,
#[serde(rename = "defaultAction")]
pub default_action: String,
#[serde(rename = "userPoolId")]
pub user_pool_id: String,
}
#[derive(Debug, PartialEq)]
pub enum CreateApiCacheError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl CreateApiCacheError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateApiCacheError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateApiCacheError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(CreateApiCacheError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(CreateApiCacheError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateApiCacheError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateApiCacheError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateApiCacheError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateApiCacheError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateApiCacheError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
CreateApiCacheError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateApiCacheError::NotFound(ref cause) => write!(f, "{}", cause),
CreateApiCacheError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateApiCacheError {}
#[derive(Debug, PartialEq)]
pub enum CreateApiKeyError {
ApiKeyLimitExceeded(String),
ApiKeyValidityOutOfBounds(String),
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl CreateApiKeyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateApiKeyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ApiKeyLimitExceededException" => {
return RusotoError::Service(CreateApiKeyError::ApiKeyLimitExceeded(err.msg))
}
"ApiKeyValidityOutOfBoundsException" => {
return RusotoError::Service(CreateApiKeyError::ApiKeyValidityOutOfBounds(
err.msg,
))
}
"BadRequestException" => {
return RusotoError::Service(CreateApiKeyError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(CreateApiKeyError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateApiKeyError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateApiKeyError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateApiKeyError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateApiKeyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateApiKeyError::ApiKeyLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateApiKeyError::ApiKeyValidityOutOfBounds(ref cause) => write!(f, "{}", cause),
CreateApiKeyError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateApiKeyError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateApiKeyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateApiKeyError::NotFound(ref cause) => write!(f, "{}", cause),
CreateApiKeyError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateApiKeyError {}
#[derive(Debug, PartialEq)]
pub enum CreateDataSourceError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl CreateDataSourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDataSourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateDataSourceError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(CreateDataSourceError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(CreateDataSourceError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateDataSourceError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateDataSourceError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDataSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDataSourceError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateDataSourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
CreateDataSourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateDataSourceError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDataSourceError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDataSourceError {}
#[derive(Debug, PartialEq)]
pub enum CreateFunctionError {
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl CreateFunctionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFunctionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(CreateFunctionError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(CreateFunctionError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateFunctionError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateFunctionError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateFunctionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFunctionError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
CreateFunctionError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateFunctionError::NotFound(ref cause) => write!(f, "{}", cause),
CreateFunctionError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFunctionError {}
#[derive(Debug, PartialEq)]
pub enum CreateGraphqlApiError {
ApiLimitExceeded(String),
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
LimitExceeded(String),
Unauthorized(String),
}
impl CreateGraphqlApiError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateGraphqlApiError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ApiLimitExceededException" => {
return RusotoError::Service(CreateGraphqlApiError::ApiLimitExceeded(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(CreateGraphqlApiError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(CreateGraphqlApiError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(CreateGraphqlApiError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateGraphqlApiError::LimitExceeded(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateGraphqlApiError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateGraphqlApiError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateGraphqlApiError::ApiLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateGraphqlApiError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateGraphqlApiError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
CreateGraphqlApiError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateGraphqlApiError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateGraphqlApiError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateGraphqlApiError {}
#[derive(Debug, PartialEq)]
pub enum CreateResolverError {
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl CreateResolverError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateResolverError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(CreateResolverError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(CreateResolverError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateResolverError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateResolverError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateResolverError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateResolverError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
CreateResolverError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateResolverError::NotFound(ref cause) => write!(f, "{}", cause),
CreateResolverError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateResolverError {}
#[derive(Debug, PartialEq)]
pub enum CreateTypeError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl CreateTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTypeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateTypeError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(CreateTypeError::ConcurrentModification(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(CreateTypeError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateTypeError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateTypeError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTypeError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateTypeError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
CreateTypeError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateTypeError::NotFound(ref cause) => write!(f, "{}", cause),
CreateTypeError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTypeError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApiCacheError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteApiCacheError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApiCacheError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteApiCacheError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(DeleteApiCacheError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteApiCacheError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteApiCacheError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteApiCacheError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApiCacheError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApiCacheError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteApiCacheError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
DeleteApiCacheError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteApiCacheError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteApiCacheError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteApiCacheError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApiKeyError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteApiKeyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteApiKeyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteApiKeyError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteApiKeyError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteApiKeyError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteApiKeyError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApiKeyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApiKeyError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteApiKeyError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteApiKeyError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteApiKeyError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteApiKeyError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDataSourceError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteDataSourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDataSourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteDataSourceError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(DeleteDataSourceError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteDataSourceError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteDataSourceError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteDataSourceError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDataSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDataSourceError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteDataSourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
DeleteDataSourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteDataSourceError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteDataSourceError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDataSourceError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFunctionError {
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteFunctionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFunctionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(DeleteFunctionError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteFunctionError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteFunctionError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteFunctionError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFunctionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFunctionError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
DeleteFunctionError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteFunctionError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteFunctionError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFunctionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteGraphqlApiError {
AccessDenied(String),
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteGraphqlApiError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteGraphqlApiError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteGraphqlApiError::AccessDenied(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(DeleteGraphqlApiError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(DeleteGraphqlApiError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteGraphqlApiError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteGraphqlApiError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteGraphqlApiError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteGraphqlApiError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteGraphqlApiError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteGraphqlApiError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteGraphqlApiError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
DeleteGraphqlApiError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteGraphqlApiError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteGraphqlApiError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteGraphqlApiError {}
#[derive(Debug, PartialEq)]
pub enum DeleteResolverError {
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteResolverError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteResolverError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(DeleteResolverError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteResolverError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteResolverError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteResolverError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteResolverError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteResolverError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
DeleteResolverError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteResolverError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteResolverError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteResolverError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTypeError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTypeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteTypeError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(DeleteTypeError::ConcurrentModification(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteTypeError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteTypeError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteTypeError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTypeError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteTypeError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
DeleteTypeError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteTypeError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteTypeError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTypeError {}
#[derive(Debug, PartialEq)]
pub enum FlushApiCacheError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl FlushApiCacheError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<FlushApiCacheError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(FlushApiCacheError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(FlushApiCacheError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(FlushApiCacheError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(FlushApiCacheError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(FlushApiCacheError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for FlushApiCacheError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
FlushApiCacheError::BadRequest(ref cause) => write!(f, "{}", cause),
FlushApiCacheError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
FlushApiCacheError::InternalFailure(ref cause) => write!(f, "{}", cause),
FlushApiCacheError::NotFound(ref cause) => write!(f, "{}", cause),
FlushApiCacheError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for FlushApiCacheError {}
#[derive(Debug, PartialEq)]
pub enum GetApiCacheError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl GetApiCacheError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetApiCacheError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetApiCacheError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(GetApiCacheError::ConcurrentModification(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetApiCacheError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetApiCacheError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetApiCacheError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetApiCacheError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetApiCacheError::BadRequest(ref cause) => write!(f, "{}", cause),
GetApiCacheError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
GetApiCacheError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetApiCacheError::NotFound(ref cause) => write!(f, "{}", cause),
GetApiCacheError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetApiCacheError {}
#[derive(Debug, PartialEq)]
pub enum GetDataSourceError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl GetDataSourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDataSourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDataSourceError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(GetDataSourceError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(GetDataSourceError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetDataSourceError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetDataSourceError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDataSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDataSourceError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDataSourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
GetDataSourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetDataSourceError::NotFound(ref cause) => write!(f, "{}", cause),
GetDataSourceError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDataSourceError {}
#[derive(Debug, PartialEq)]
pub enum GetFunctionError {
ConcurrentModification(String),
NotFound(String),
Unauthorized(String),
}
impl GetFunctionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFunctionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(GetFunctionError::ConcurrentModification(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetFunctionError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetFunctionError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFunctionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFunctionError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
GetFunctionError::NotFound(ref cause) => write!(f, "{}", cause),
GetFunctionError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFunctionError {}
#[derive(Debug, PartialEq)]
pub enum GetGraphqlApiError {
AccessDenied(String),
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl GetGraphqlApiError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetGraphqlApiError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetGraphqlApiError::AccessDenied(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(GetGraphqlApiError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetGraphqlApiError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetGraphqlApiError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetGraphqlApiError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetGraphqlApiError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetGraphqlApiError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetGraphqlApiError::BadRequest(ref cause) => write!(f, "{}", cause),
GetGraphqlApiError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetGraphqlApiError::NotFound(ref cause) => write!(f, "{}", cause),
GetGraphqlApiError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetGraphqlApiError {}
#[derive(Debug, PartialEq)]
pub enum GetIntrospectionSchemaError {
GraphQLSchema(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl GetIntrospectionSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetIntrospectionSchemaError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"GraphQLSchemaException" => {
return RusotoError::Service(GetIntrospectionSchemaError::GraphQLSchema(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(GetIntrospectionSchemaError::InternalFailure(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetIntrospectionSchemaError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetIntrospectionSchemaError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetIntrospectionSchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetIntrospectionSchemaError::GraphQLSchema(ref cause) => write!(f, "{}", cause),
GetIntrospectionSchemaError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetIntrospectionSchemaError::NotFound(ref cause) => write!(f, "{}", cause),
GetIntrospectionSchemaError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetIntrospectionSchemaError {}
#[derive(Debug, PartialEq)]
pub enum GetResolverError {
ConcurrentModification(String),
NotFound(String),
Unauthorized(String),
}
impl GetResolverError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetResolverError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(GetResolverError::ConcurrentModification(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetResolverError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetResolverError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetResolverError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetResolverError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
GetResolverError::NotFound(ref cause) => write!(f, "{}", cause),
GetResolverError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetResolverError {}
#[derive(Debug, PartialEq)]
pub enum GetSchemaCreationStatusError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl GetSchemaCreationStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSchemaCreationStatusError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetSchemaCreationStatusError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetSchemaCreationStatusError::InternalFailure(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetSchemaCreationStatusError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetSchemaCreationStatusError::Unauthorized(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSchemaCreationStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSchemaCreationStatusError::BadRequest(ref cause) => write!(f, "{}", cause),
GetSchemaCreationStatusError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetSchemaCreationStatusError::NotFound(ref cause) => write!(f, "{}", cause),
GetSchemaCreationStatusError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSchemaCreationStatusError {}
#[derive(Debug, PartialEq)]
pub enum GetTypeError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl GetTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetTypeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetTypeError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(GetTypeError::ConcurrentModification(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetTypeError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetTypeError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetTypeError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTypeError::BadRequest(ref cause) => write!(f, "{}", cause),
GetTypeError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
GetTypeError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetTypeError::NotFound(ref cause) => write!(f, "{}", cause),
GetTypeError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetTypeError {}
#[derive(Debug, PartialEq)]
pub enum ListApiKeysError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl ListApiKeysError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListApiKeysError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListApiKeysError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListApiKeysError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListApiKeysError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListApiKeysError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListApiKeysError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListApiKeysError::BadRequest(ref cause) => write!(f, "{}", cause),
ListApiKeysError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListApiKeysError::NotFound(ref cause) => write!(f, "{}", cause),
ListApiKeysError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListApiKeysError {}
#[derive(Debug, PartialEq)]
pub enum ListDataSourcesError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl ListDataSourcesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDataSourcesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListDataSourcesError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListDataSourcesError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListDataSourcesError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListDataSourcesError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDataSourcesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDataSourcesError::BadRequest(ref cause) => write!(f, "{}", cause),
ListDataSourcesError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListDataSourcesError::NotFound(ref cause) => write!(f, "{}", cause),
ListDataSourcesError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDataSourcesError {}
#[derive(Debug, PartialEq)]
pub enum ListFunctionsError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl ListFunctionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFunctionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListFunctionsError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListFunctionsError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListFunctionsError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListFunctionsError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFunctionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFunctionsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListFunctionsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListFunctionsError::NotFound(ref cause) => write!(f, "{}", cause),
ListFunctionsError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFunctionsError {}
#[derive(Debug, PartialEq)]
pub enum ListGraphqlApisError {
BadRequest(String),
InternalFailure(String),
Unauthorized(String),
}
impl ListGraphqlApisError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListGraphqlApisError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListGraphqlApisError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListGraphqlApisError::InternalFailure(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListGraphqlApisError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListGraphqlApisError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListGraphqlApisError::BadRequest(ref cause) => write!(f, "{}", cause),
ListGraphqlApisError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListGraphqlApisError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListGraphqlApisError {}
#[derive(Debug, PartialEq)]
pub enum ListResolversError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl ListResolversError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListResolversError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListResolversError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListResolversError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListResolversError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListResolversError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResolversError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResolversError::BadRequest(ref cause) => write!(f, "{}", cause),
ListResolversError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListResolversError::NotFound(ref cause) => write!(f, "{}", cause),
ListResolversError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResolversError {}
#[derive(Debug, PartialEq)]
pub enum ListResolversByFunctionError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl ListResolversByFunctionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListResolversByFunctionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListResolversByFunctionError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListResolversByFunctionError::InternalFailure(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(ListResolversByFunctionError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListResolversByFunctionError::Unauthorized(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListResolversByFunctionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListResolversByFunctionError::BadRequest(ref cause) => write!(f, "{}", cause),
ListResolversByFunctionError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListResolversByFunctionError::NotFound(ref cause) => write!(f, "{}", cause),
ListResolversByFunctionError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListResolversByFunctionError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
AccessDenied(String),
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListTagsForResourceError::AccessDenied(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(ListTagsForResourceError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListTagsForResourceError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListTagsForResourceError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListTagsForResourceError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::NotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListTypesError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl ListTypesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTypesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListTypesError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(ListTypesError::ConcurrentModification(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListTypesError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(ListTypesError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListTypesError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTypesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTypesError::BadRequest(ref cause) => write!(f, "{}", cause),
ListTypesError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
ListTypesError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListTypesError::NotFound(ref cause) => write!(f, "{}", cause),
ListTypesError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTypesError {}
#[derive(Debug, PartialEq)]
pub enum StartSchemaCreationError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl StartSchemaCreationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartSchemaCreationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StartSchemaCreationError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(StartSchemaCreationError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(StartSchemaCreationError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(StartSchemaCreationError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(StartSchemaCreationError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartSchemaCreationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartSchemaCreationError::BadRequest(ref cause) => write!(f, "{}", cause),
StartSchemaCreationError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
StartSchemaCreationError::InternalFailure(ref cause) => write!(f, "{}", cause),
StartSchemaCreationError::NotFound(ref cause) => write!(f, "{}", cause),
StartSchemaCreationError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartSchemaCreationError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
AccessDenied(String),
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(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() {
"AccessDeniedException" => {
return RusotoError::Service(TagResourceError::AccessDenied(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(TagResourceError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(TagResourceError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(TagResourceError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(TagResourceError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(TagResourceError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
TagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
TagResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
TagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
AccessDenied(String),
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(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() {
"AccessDeniedException" => {
return RusotoError::Service(UntagResourceError::AccessDenied(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(UntagResourceError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(UntagResourceError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UntagResourceError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UntagResourceError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UntagResourceError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
UntagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
UntagResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UntagResourceError::NotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApiCacheError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl UpdateApiCacheError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateApiCacheError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateApiCacheError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(UpdateApiCacheError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateApiCacheError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateApiCacheError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateApiCacheError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateApiCacheError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateApiCacheError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateApiCacheError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UpdateApiCacheError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateApiCacheError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateApiCacheError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateApiCacheError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApiKeyError {
ApiKeyValidityOutOfBounds(String),
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl UpdateApiKeyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateApiKeyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ApiKeyValidityOutOfBoundsException" => {
return RusotoError::Service(UpdateApiKeyError::ApiKeyValidityOutOfBounds(
err.msg,
))
}
"BadRequestException" => {
return RusotoError::Service(UpdateApiKeyError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateApiKeyError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateApiKeyError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateApiKeyError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateApiKeyError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateApiKeyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateApiKeyError::ApiKeyValidityOutOfBounds(ref cause) => write!(f, "{}", cause),
UpdateApiKeyError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateApiKeyError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateApiKeyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateApiKeyError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateApiKeyError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateApiKeyError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDataSourceError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl UpdateDataSourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDataSourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateDataSourceError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(UpdateDataSourceError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateDataSourceError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateDataSourceError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateDataSourceError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDataSourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDataSourceError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateDataSourceError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UpdateDataSourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateDataSourceError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateDataSourceError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDataSourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFunctionError {
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl UpdateFunctionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFunctionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(UpdateFunctionError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateFunctionError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateFunctionError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateFunctionError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFunctionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFunctionError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UpdateFunctionError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateFunctionError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateFunctionError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFunctionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateGraphqlApiError {
AccessDenied(String),
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl UpdateGraphqlApiError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateGraphqlApiError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateGraphqlApiError::AccessDenied(err.msg))
}
"BadRequestException" => {
return RusotoError::Service(UpdateGraphqlApiError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(UpdateGraphqlApiError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateGraphqlApiError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateGraphqlApiError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateGraphqlApiError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateGraphqlApiError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateGraphqlApiError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateGraphqlApiError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateGraphqlApiError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UpdateGraphqlApiError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateGraphqlApiError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateGraphqlApiError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateGraphqlApiError {}
#[derive(Debug, PartialEq)]
pub enum UpdateResolverError {
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl UpdateResolverError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateResolverError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ConcurrentModificationException" => {
return RusotoError::Service(UpdateResolverError::ConcurrentModification(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateResolverError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateResolverError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateResolverError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateResolverError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateResolverError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UpdateResolverError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateResolverError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateResolverError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateResolverError {}
#[derive(Debug, PartialEq)]
pub enum UpdateTypeError {
BadRequest(String),
ConcurrentModification(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl UpdateTypeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateTypeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateTypeError::BadRequest(err.msg))
}
"ConcurrentModificationException" => {
return RusotoError::Service(UpdateTypeError::ConcurrentModification(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateTypeError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateTypeError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateTypeError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateTypeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateTypeError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateTypeError::ConcurrentModification(ref cause) => write!(f, "{}", cause),
UpdateTypeError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateTypeError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateTypeError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateTypeError {}
#[async_trait]
pub trait AppSync {
async fn create_api_cache(
&self,
input: CreateApiCacheRequest,
) -> Result<CreateApiCacheResponse, RusotoError<CreateApiCacheError>>;
async fn create_api_key(
&self,
input: CreateApiKeyRequest,
) -> Result<CreateApiKeyResponse, RusotoError<CreateApiKeyError>>;
async fn create_data_source(
&self,
input: CreateDataSourceRequest,
) -> Result<CreateDataSourceResponse, RusotoError<CreateDataSourceError>>;
async fn create_function(
&self,
input: CreateFunctionRequest,
) -> Result<CreateFunctionResponse, RusotoError<CreateFunctionError>>;
async fn create_graphql_api(
&self,
input: CreateGraphqlApiRequest,
) -> Result<CreateGraphqlApiResponse, RusotoError<CreateGraphqlApiError>>;
async fn create_resolver(
&self,
input: CreateResolverRequest,
) -> Result<CreateResolverResponse, RusotoError<CreateResolverError>>;
async fn create_type(
&self,
input: CreateTypeRequest,
) -> Result<CreateTypeResponse, RusotoError<CreateTypeError>>;
async fn delete_api_cache(
&self,
input: DeleteApiCacheRequest,
) -> Result<DeleteApiCacheResponse, RusotoError<DeleteApiCacheError>>;
async fn delete_api_key(
&self,
input: DeleteApiKeyRequest,
) -> Result<DeleteApiKeyResponse, RusotoError<DeleteApiKeyError>>;
async fn delete_data_source(
&self,
input: DeleteDataSourceRequest,
) -> Result<DeleteDataSourceResponse, RusotoError<DeleteDataSourceError>>;
async fn delete_function(
&self,
input: DeleteFunctionRequest,
) -> Result<DeleteFunctionResponse, RusotoError<DeleteFunctionError>>;
async fn delete_graphql_api(
&self,
input: DeleteGraphqlApiRequest,
) -> Result<DeleteGraphqlApiResponse, RusotoError<DeleteGraphqlApiError>>;
async fn delete_resolver(
&self,
input: DeleteResolverRequest,
) -> Result<DeleteResolverResponse, RusotoError<DeleteResolverError>>;
async fn delete_type(
&self,
input: DeleteTypeRequest,
) -> Result<DeleteTypeResponse, RusotoError<DeleteTypeError>>;
async fn flush_api_cache(
&self,
input: FlushApiCacheRequest,
) -> Result<FlushApiCacheResponse, RusotoError<FlushApiCacheError>>;
async fn get_api_cache(
&self,
input: GetApiCacheRequest,
) -> Result<GetApiCacheResponse, RusotoError<GetApiCacheError>>;
async fn get_data_source(
&self,
input: GetDataSourceRequest,
) -> Result<GetDataSourceResponse, RusotoError<GetDataSourceError>>;
async fn get_function(
&self,
input: GetFunctionRequest,
) -> Result<GetFunctionResponse, RusotoError<GetFunctionError>>;
async fn get_graphql_api(
&self,
input: GetGraphqlApiRequest,
) -> Result<GetGraphqlApiResponse, RusotoError<GetGraphqlApiError>>;
async fn get_introspection_schema(
&self,
input: GetIntrospectionSchemaRequest,
) -> Result<GetIntrospectionSchemaResponse, RusotoError<GetIntrospectionSchemaError>>;
async fn get_resolver(
&self,
input: GetResolverRequest,
) -> Result<GetResolverResponse, RusotoError<GetResolverError>>;
async fn get_schema_creation_status(
&self,
input: GetSchemaCreationStatusRequest,
) -> Result<GetSchemaCreationStatusResponse, RusotoError<GetSchemaCreationStatusError>>;
async fn get_type(
&self,
input: GetTypeRequest,
) -> Result<GetTypeResponse, RusotoError<GetTypeError>>;
async fn list_api_keys(
&self,
input: ListApiKeysRequest,
) -> Result<ListApiKeysResponse, RusotoError<ListApiKeysError>>;
async fn list_data_sources(
&self,
input: ListDataSourcesRequest,
) -> Result<ListDataSourcesResponse, RusotoError<ListDataSourcesError>>;
async fn list_functions(
&self,
input: ListFunctionsRequest,
) -> Result<ListFunctionsResponse, RusotoError<ListFunctionsError>>;
async fn list_graphql_apis(
&self,
input: ListGraphqlApisRequest,
) -> Result<ListGraphqlApisResponse, RusotoError<ListGraphqlApisError>>;
async fn list_resolvers(
&self,
input: ListResolversRequest,
) -> Result<ListResolversResponse, RusotoError<ListResolversError>>;
async fn list_resolvers_by_function(
&self,
input: ListResolversByFunctionRequest,
) -> Result<ListResolversByFunctionResponse, RusotoError<ListResolversByFunctionError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_types(
&self,
input: ListTypesRequest,
) -> Result<ListTypesResponse, RusotoError<ListTypesError>>;
async fn start_schema_creation(
&self,
input: StartSchemaCreationRequest,
) -> Result<StartSchemaCreationResponse, RusotoError<StartSchemaCreationError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_api_cache(
&self,
input: UpdateApiCacheRequest,
) -> Result<UpdateApiCacheResponse, RusotoError<UpdateApiCacheError>>;
async fn update_api_key(
&self,
input: UpdateApiKeyRequest,
) -> Result<UpdateApiKeyResponse, RusotoError<UpdateApiKeyError>>;
async fn update_data_source(
&self,
input: UpdateDataSourceRequest,
) -> Result<UpdateDataSourceResponse, RusotoError<UpdateDataSourceError>>;
async fn update_function(
&self,
input: UpdateFunctionRequest,
) -> Result<UpdateFunctionResponse, RusotoError<UpdateFunctionError>>;
async fn update_graphql_api(
&self,
input: UpdateGraphqlApiRequest,
) -> Result<UpdateGraphqlApiResponse, RusotoError<UpdateGraphqlApiError>>;
async fn update_resolver(
&self,
input: UpdateResolverRequest,
) -> Result<UpdateResolverResponse, RusotoError<UpdateResolverError>>;
async fn update_type(
&self,
input: UpdateTypeRequest,
) -> Result<UpdateTypeResponse, RusotoError<UpdateTypeError>>;
}
#[derive(Clone)]
pub struct AppSyncClient {
client: Client,
region: region::Region,
}
impl AppSyncClient {
pub fn new(region: region::Region) -> AppSyncClient {
AppSyncClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> AppSyncClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
AppSyncClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> AppSyncClient {
AppSyncClient { client, region }
}
}
#[async_trait]
impl AppSync for AppSyncClient {
#[allow(unused_mut)]
async fn create_api_cache(
&self,
input: CreateApiCacheRequest,
) -> Result<CreateApiCacheResponse, RusotoError<CreateApiCacheError>> {
let request_uri = format!("/v1/apis/{api_id}/ApiCaches", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateApiCacheResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateApiCacheError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_api_key(
&self,
input: CreateApiKeyRequest,
) -> Result<CreateApiKeyResponse, RusotoError<CreateApiKeyError>> {
let request_uri = format!("/v1/apis/{api_id}/apikeys", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateApiKeyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateApiKeyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_data_source(
&self,
input: CreateDataSourceRequest,
) -> Result<CreateDataSourceResponse, RusotoError<CreateDataSourceError>> {
let request_uri = format!("/v1/apis/{api_id}/datasources", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDataSourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDataSourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_function(
&self,
input: CreateFunctionRequest,
) -> Result<CreateFunctionResponse, RusotoError<CreateFunctionError>> {
let request_uri = format!("/v1/apis/{api_id}/functions", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateFunctionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateFunctionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_graphql_api(
&self,
input: CreateGraphqlApiRequest,
) -> Result<CreateGraphqlApiResponse, RusotoError<CreateGraphqlApiError>> {
let request_uri = "/v1/apis";
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateGraphqlApiResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateGraphqlApiError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_resolver(
&self,
input: CreateResolverRequest,
) -> Result<CreateResolverResponse, RusotoError<CreateResolverError>> {
let request_uri = format!(
"/v1/apis/{api_id}/types/{type_name}/resolvers",
api_id = input.api_id,
type_name = input.type_name
);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateResolverResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateResolverError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_type(
&self,
input: CreateTypeRequest,
) -> Result<CreateTypeResponse, RusotoError<CreateTypeError>> {
let request_uri = format!("/v1/apis/{api_id}/types", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateTypeResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateTypeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_api_cache(
&self,
input: DeleteApiCacheRequest,
) -> Result<DeleteApiCacheResponse, RusotoError<DeleteApiCacheError>> {
let request_uri = format!("/v1/apis/{api_id}/ApiCaches", api_id = input.api_id);
let mut request = SignedRequest::new("DELETE", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteApiCacheResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApiCacheError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_api_key(
&self,
input: DeleteApiKeyRequest,
) -> Result<DeleteApiKeyResponse, RusotoError<DeleteApiKeyError>> {
let request_uri = format!(
"/v1/apis/{api_id}/apikeys/{id}",
api_id = input.api_id,
id = input.id
);
let mut request = SignedRequest::new("DELETE", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteApiKeyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteApiKeyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_data_source(
&self,
input: DeleteDataSourceRequest,
) -> Result<DeleteDataSourceResponse, RusotoError<DeleteDataSourceError>> {
let request_uri = format!(
"/v1/apis/{api_id}/datasources/{name}",
api_id = input.api_id,
name = input.name
);
let mut request = SignedRequest::new("DELETE", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteDataSourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDataSourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_function(
&self,
input: DeleteFunctionRequest,
) -> Result<DeleteFunctionResponse, RusotoError<DeleteFunctionError>> {
let request_uri = format!(
"/v1/apis/{api_id}/functions/{function_id}",
api_id = input.api_id,
function_id = input.function_id
);
let mut request = SignedRequest::new("DELETE", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteFunctionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFunctionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_graphql_api(
&self,
input: DeleteGraphqlApiRequest,
) -> Result<DeleteGraphqlApiResponse, RusotoError<DeleteGraphqlApiError>> {
let request_uri = format!("/v1/apis/{api_id}", api_id = input.api_id);
let mut request = SignedRequest::new("DELETE", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteGraphqlApiResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteGraphqlApiError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_resolver(
&self,
input: DeleteResolverRequest,
) -> Result<DeleteResolverResponse, RusotoError<DeleteResolverError>> {
let request_uri = format!(
"/v1/apis/{api_id}/types/{type_name}/resolvers/{field_name}",
api_id = input.api_id,
field_name = input.field_name,
type_name = input.type_name
);
let mut request = SignedRequest::new("DELETE", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteResolverResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteResolverError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_type(
&self,
input: DeleteTypeRequest,
) -> Result<DeleteTypeResponse, RusotoError<DeleteTypeError>> {
let request_uri = format!(
"/v1/apis/{api_id}/types/{type_name}",
api_id = input.api_id,
type_name = input.type_name
);
let mut request = SignedRequest::new("DELETE", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteTypeResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteTypeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn flush_api_cache(
&self,
input: FlushApiCacheRequest,
) -> Result<FlushApiCacheResponse, RusotoError<FlushApiCacheError>> {
let request_uri = format!("/v1/apis/{api_id}/FlushCache", api_id = input.api_id);
let mut request = SignedRequest::new("DELETE", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<FlushApiCacheResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(FlushApiCacheError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_api_cache(
&self,
input: GetApiCacheRequest,
) -> Result<GetApiCacheResponse, RusotoError<GetApiCacheError>> {
let request_uri = format!("/v1/apis/{api_id}/ApiCaches", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetApiCacheResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetApiCacheError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_data_source(
&self,
input: GetDataSourceRequest,
) -> Result<GetDataSourceResponse, RusotoError<GetDataSourceError>> {
let request_uri = format!(
"/v1/apis/{api_id}/datasources/{name}",
api_id = input.api_id,
name = input.name
);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDataSourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDataSourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_function(
&self,
input: GetFunctionRequest,
) -> Result<GetFunctionResponse, RusotoError<GetFunctionError>> {
let request_uri = format!(
"/v1/apis/{api_id}/functions/{function_id}",
api_id = input.api_id,
function_id = input.function_id
);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetFunctionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFunctionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_graphql_api(
&self,
input: GetGraphqlApiRequest,
) -> Result<GetGraphqlApiResponse, RusotoError<GetGraphqlApiError>> {
let request_uri = format!("/v1/apis/{api_id}", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetGraphqlApiResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetGraphqlApiError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_introspection_schema(
&self,
input: GetIntrospectionSchemaRequest,
) -> Result<GetIntrospectionSchemaResponse, RusotoError<GetIntrospectionSchemaError>> {
let request_uri = format!("/v1/apis/{api_id}/schema", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "appsync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("format", &input.format);
if let Some(ref x) = input.include_directives {
params.put("includeDirectives", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let mut result = GetIntrospectionSchemaResponse::default();
result.schema = Some(response.body);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetIntrospectionSchemaError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_resolver(
&self,
input: GetResolverRequest,
) -> Result<GetResolverResponse, RusotoError<GetResolverError>> {
let request_uri = format!(
"/v1/apis/{api_id}/types/{type_name}/resolvers/{field_name}",
api_id = input.api_id,
field_name = input.field_name,
type_name = input.type_name
);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetResolverResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetResolverError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_schema_creation_status(
&self,
input: GetSchemaCreationStatusRequest,
) -> Result<GetSchemaCreationStatusResponse, RusotoError<GetSchemaCreationStatusError>> {
let request_uri = format!("/v1/apis/{api_id}/schemacreation", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetSchemaCreationStatusResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetSchemaCreationStatusError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_type(
&self,
input: GetTypeRequest,
) -> Result<GetTypeResponse, RusotoError<GetTypeError>> {
let request_uri = format!(
"/v1/apis/{api_id}/types/{type_name}",
api_id = input.api_id,
type_name = input.type_name
);
let mut request = SignedRequest::new("GET", "appsync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("format", &input.format);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<GetTypeResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetTypeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_api_keys(
&self,
input: ListApiKeysRequest,
) -> Result<ListApiKeysResponse, RusotoError<ListApiKeysError>> {
let request_uri = format!("/v1/apis/{api_id}/apikeys", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListApiKeysResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListApiKeysError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_data_sources(
&self,
input: ListDataSourcesRequest,
) -> Result<ListDataSourcesResponse, RusotoError<ListDataSourcesError>> {
let request_uri = format!("/v1/apis/{api_id}/datasources", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDataSourcesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDataSourcesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_functions(
&self,
input: ListFunctionsRequest,
) -> Result<ListFunctionsResponse, RusotoError<ListFunctionsError>> {
let request_uri = format!("/v1/apis/{api_id}/functions", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFunctionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFunctionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_graphql_apis(
&self,
input: ListGraphqlApisRequest,
) -> Result<ListGraphqlApisResponse, RusotoError<ListGraphqlApisError>> {
let request_uri = "/v1/apis";
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListGraphqlApisResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListGraphqlApisError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_resolvers(
&self,
input: ListResolversRequest,
) -> Result<ListResolversResponse, RusotoError<ListResolversError>> {
let request_uri = format!(
"/v1/apis/{api_id}/types/{type_name}/resolvers",
api_id = input.api_id,
type_name = input.type_name
);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListResolversResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListResolversError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_resolvers_by_function(
&self,
input: ListResolversByFunctionRequest,
) -> Result<ListResolversByFunctionResponse, RusotoError<ListResolversByFunctionError>> {
let request_uri = format!(
"/v1/apis/{api_id}/functions/{function_id}/resolvers",
api_id = input.api_id,
function_id = input.function_id
);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListResolversByFunctionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListResolversByFunctionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/v1/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_types(
&self,
input: ListTypesRequest,
) -> Result<ListTypesResponse, RusotoError<ListTypesError>> {
let request_uri = format!("/v1/apis/{api_id}/types", api_id = input.api_id);
let mut request = SignedRequest::new("GET", "appsync", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("format", &input.format);
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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTypesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTypesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_schema_creation(
&self,
input: StartSchemaCreationRequest,
) -> Result<StartSchemaCreationResponse, RusotoError<StartSchemaCreationError>> {
let request_uri = format!("/v1/apis/{api_id}/schemacreation", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartSchemaCreationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartSchemaCreationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = format!("/v1/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
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<UntagResourceResponse, RusotoError<UntagResourceError>> {
let request_uri = format!("/v1/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_api_cache(
&self,
input: UpdateApiCacheRequest,
) -> Result<UpdateApiCacheResponse, RusotoError<UpdateApiCacheError>> {
let request_uri = format!("/v1/apis/{api_id}/ApiCaches/update", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateApiCacheResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateApiCacheError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_api_key(
&self,
input: UpdateApiKeyRequest,
) -> Result<UpdateApiKeyResponse, RusotoError<UpdateApiKeyError>> {
let request_uri = format!(
"/v1/apis/{api_id}/apikeys/{id}",
api_id = input.api_id,
id = input.id
);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateApiKeyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateApiKeyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_data_source(
&self,
input: UpdateDataSourceRequest,
) -> Result<UpdateDataSourceResponse, RusotoError<UpdateDataSourceError>> {
let request_uri = format!(
"/v1/apis/{api_id}/datasources/{name}",
api_id = input.api_id,
name = input.name
);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateDataSourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDataSourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_function(
&self,
input: UpdateFunctionRequest,
) -> Result<UpdateFunctionResponse, RusotoError<UpdateFunctionError>> {
let request_uri = format!(
"/v1/apis/{api_id}/functions/{function_id}",
api_id = input.api_id,
function_id = input.function_id
);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateFunctionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFunctionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_graphql_api(
&self,
input: UpdateGraphqlApiRequest,
) -> Result<UpdateGraphqlApiResponse, RusotoError<UpdateGraphqlApiError>> {
let request_uri = format!("/v1/apis/{api_id}", api_id = input.api_id);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateGraphqlApiResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateGraphqlApiError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_resolver(
&self,
input: UpdateResolverRequest,
) -> Result<UpdateResolverResponse, RusotoError<UpdateResolverError>> {
let request_uri = format!(
"/v1/apis/{api_id}/types/{type_name}/resolvers/{field_name}",
api_id = input.api_id,
field_name = input.field_name,
type_name = input.type_name
);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateResolverResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateResolverError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_type(
&self,
input: UpdateTypeRequest,
) -> Result<UpdateTypeResponse, RusotoError<UpdateTypeError>> {
let request_uri = format!(
"/v1/apis/{api_id}/types/{type_name}",
api_id = input.api_id,
type_name = input.type_name
);
let mut request = SignedRequest::new("POST", "appsync", &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.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateTypeResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateTypeError::from_response(response))
}
}
}