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)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AccountLimit {
#[serde(rename = "CodeSizeUnzipped")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_size_unzipped: Option<i64>,
#[serde(rename = "CodeSizeZipped")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_size_zipped: Option<i64>,
#[serde(rename = "ConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub concurrent_executions: Option<i64>,
#[serde(rename = "TotalCodeSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_code_size: Option<i64>,
#[serde(rename = "UnreservedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unreserved_concurrent_executions: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AccountUsage {
#[serde(rename = "FunctionCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_count: Option<i64>,
#[serde(rename = "TotalCodeSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub total_code_size: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddLayerVersionPermissionRequest {
#[serde(rename = "Action")]
pub action: String,
#[serde(rename = "LayerName")]
pub layer_name: String,
#[serde(rename = "OrganizationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub organization_id: Option<String>,
#[serde(rename = "Principal")]
pub principal: String,
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "StatementId")]
pub statement_id: String,
#[serde(rename = "VersionNumber")]
pub version_number: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddLayerVersionPermissionResponse {
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "Statement")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statement: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddPermissionRequest {
#[serde(rename = "Action")]
pub action: String,
#[serde(rename = "EventSourceToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_source_token: Option<String>,
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Principal")]
pub principal: String,
#[serde(rename = "Qualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifier: Option<String>,
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "SourceAccount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_account: Option<String>,
#[serde(rename = "SourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_arn: Option<String>,
#[serde(rename = "StatementId")]
pub statement_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddPermissionResponse {
#[serde(rename = "Statement")]
#[serde(skip_serializing_if = "Option::is_none")]
pub statement: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AliasConfiguration {
#[serde(rename = "AliasArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub alias_arn: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: 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 = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "RoutingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub routing_config: Option<AliasRoutingConfiguration>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AliasRoutingConfiguration {
#[serde(rename = "AdditionalVersionWeights")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_version_weights: Option<::std::collections::HashMap<String, f64>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AllowedPublishers {
#[serde(rename = "SigningProfileVersionArns")]
pub signing_profile_version_arns: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CodeSigningConfig {
#[serde(rename = "AllowedPublishers")]
pub allowed_publishers: AllowedPublishers,
#[serde(rename = "CodeSigningConfigArn")]
pub code_signing_config_arn: String,
#[serde(rename = "CodeSigningConfigId")]
pub code_signing_config_id: String,
#[serde(rename = "CodeSigningPolicies")]
pub code_signing_policies: CodeSigningPolicies,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LastModified")]
pub last_modified: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CodeSigningPolicies {
#[serde(rename = "UntrustedArtifactOnDeployment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub untrusted_artifact_on_deployment: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Concurrency {
#[serde(rename = "ReservedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reserved_concurrent_executions: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAliasRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "FunctionVersion")]
pub function_version: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RoutingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub routing_config: Option<AliasRoutingConfiguration>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCodeSigningConfigRequest {
#[serde(rename = "AllowedPublishers")]
pub allowed_publishers: AllowedPublishers,
#[serde(rename = "CodeSigningPolicies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_signing_policies: Option<CodeSigningPolicies>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCodeSigningConfigResponse {
#[serde(rename = "CodeSigningConfig")]
pub code_signing_config: CodeSigningConfig,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateEventSourceMappingRequest {
#[serde(rename = "BatchSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_size: Option<i64>,
#[serde(rename = "BisectBatchOnFunctionError")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bisect_batch_on_function_error: Option<bool>,
#[serde(rename = "DestinationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_config: Option<DestinationConfig>,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "EventSourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_source_arn: Option<String>,
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "FunctionResponseTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_response_types: Option<Vec<String>>,
#[serde(rename = "MaximumBatchingWindowInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_batching_window_in_seconds: Option<i64>,
#[serde(rename = "MaximumRecordAgeInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_record_age_in_seconds: Option<i64>,
#[serde(rename = "MaximumRetryAttempts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_retry_attempts: Option<i64>,
#[serde(rename = "ParallelizationFactor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelization_factor: Option<i64>,
#[serde(rename = "Queues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queues: Option<Vec<String>>,
#[serde(rename = "SelfManagedEventSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub self_managed_event_source: Option<SelfManagedEventSource>,
#[serde(rename = "SourceAccessConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_access_configurations: Option<Vec<SourceAccessConfiguration>>,
#[serde(rename = "StartingPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub starting_position: Option<String>,
#[serde(rename = "StartingPositionTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub starting_position_timestamp: Option<f64>,
#[serde(rename = "Topics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub topics: Option<Vec<String>>,
#[serde(rename = "TumblingWindowInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tumbling_window_in_seconds: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFunctionRequest {
#[serde(rename = "Code")]
pub code: FunctionCode,
#[serde(rename = "CodeSigningConfigArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_signing_config_arn: Option<String>,
#[serde(rename = "DeadLetterConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dead_letter_config: Option<DeadLetterConfig>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Environment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<Environment>,
#[serde(rename = "FileSystemConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_system_configs: Option<Vec<FileSystemConfig>>,
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Handler")]
#[serde(skip_serializing_if = "Option::is_none")]
pub handler: Option<String>,
#[serde(rename = "ImageConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_config: Option<ImageConfig>,
#[serde(rename = "KMSKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_arn: Option<String>,
#[serde(rename = "Layers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layers: Option<Vec<String>>,
#[serde(rename = "MemorySize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub memory_size: Option<i64>,
#[serde(rename = "PackageType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_type: Option<String>,
#[serde(rename = "Publish")]
#[serde(skip_serializing_if = "Option::is_none")]
pub publish: Option<bool>,
#[serde(rename = "Role")]
pub role: String,
#[serde(rename = "Runtime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub runtime: Option<String>,
#[serde(rename = "Tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Timeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<i64>,
#[serde(rename = "TracingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracing_config: Option<TracingConfig>,
#[serde(rename = "VpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VpcConfig>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DeadLetterConfig {
#[serde(rename = "TargetArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAliasRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCodeSigningConfigRequest {
#[serde(rename = "CodeSigningConfigArn")]
pub code_signing_config_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteCodeSigningConfigResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteEventSourceMappingRequest {
#[serde(rename = "UUID")]
pub uuid: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFunctionCodeSigningConfigRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFunctionConcurrencyRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFunctionEventInvokeConfigRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Qualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFunctionRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Qualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteLayerVersionRequest {
#[serde(rename = "LayerName")]
pub layer_name: String,
#[serde(rename = "VersionNumber")]
pub version_number: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteProvisionedConcurrencyConfigRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Qualifier")]
pub qualifier: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct DestinationConfig {
#[serde(rename = "OnFailure")]
#[serde(skip_serializing_if = "Option::is_none")]
pub on_failure: Option<OnFailure>,
#[serde(rename = "OnSuccess")]
#[serde(skip_serializing_if = "Option::is_none")]
pub on_success: Option<OnSuccess>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Environment {
#[serde(rename = "Variables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub variables: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnvironmentError {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnvironmentResponse {
#[serde(rename = "Error")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error: Option<EnvironmentError>,
#[serde(rename = "Variables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub variables: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EventSourceMappingConfiguration {
#[serde(rename = "BatchSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_size: Option<i64>,
#[serde(rename = "BisectBatchOnFunctionError")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bisect_batch_on_function_error: Option<bool>,
#[serde(rename = "DestinationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_config: Option<DestinationConfig>,
#[serde(rename = "EventSourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_source_arn: Option<String>,
#[serde(rename = "FunctionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_arn: Option<String>,
#[serde(rename = "FunctionResponseTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_response_types: Option<Vec<String>>,
#[serde(rename = "LastModified")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified: Option<f64>,
#[serde(rename = "LastProcessingResult")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_processing_result: Option<String>,
#[serde(rename = "MaximumBatchingWindowInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_batching_window_in_seconds: Option<i64>,
#[serde(rename = "MaximumRecordAgeInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_record_age_in_seconds: Option<i64>,
#[serde(rename = "MaximumRetryAttempts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_retry_attempts: Option<i64>,
#[serde(rename = "ParallelizationFactor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelization_factor: Option<i64>,
#[serde(rename = "Queues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub queues: Option<Vec<String>>,
#[serde(rename = "SelfManagedEventSource")]
#[serde(skip_serializing_if = "Option::is_none")]
pub self_managed_event_source: Option<SelfManagedEventSource>,
#[serde(rename = "SourceAccessConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_access_configurations: Option<Vec<SourceAccessConfiguration>>,
#[serde(rename = "StartingPosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub starting_position: Option<String>,
#[serde(rename = "StartingPositionTimestamp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub starting_position_timestamp: Option<f64>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StateTransitionReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_transition_reason: Option<String>,
#[serde(rename = "Topics")]
#[serde(skip_serializing_if = "Option::is_none")]
pub topics: Option<Vec<String>>,
#[serde(rename = "TumblingWindowInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tumbling_window_in_seconds: Option<i64>,
#[serde(rename = "UUID")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uuid: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FileSystemConfig {
#[serde(rename = "Arn")]
pub arn: String,
#[serde(rename = "LocalMountPath")]
pub local_mount_path: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FunctionCode {
#[serde(rename = "ImageUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_uri: Option<String>,
#[serde(rename = "S3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_bucket: Option<String>,
#[serde(rename = "S3Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_key: Option<String>,
#[serde(rename = "S3ObjectVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_object_version: Option<String>,
#[serde(rename = "ZipFile")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub zip_file: Option<bytes::Bytes>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FunctionCodeLocation {
#[serde(rename = "ImageUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_uri: Option<String>,
#[serde(rename = "Location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(rename = "RepositoryType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_type: Option<String>,
#[serde(rename = "ResolvedImageUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub resolved_image_uri: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FunctionConfiguration {
#[serde(rename = "CodeSha256")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_sha_256: Option<String>,
#[serde(rename = "CodeSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_size: Option<i64>,
#[serde(rename = "DeadLetterConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dead_letter_config: Option<DeadLetterConfig>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Environment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<EnvironmentResponse>,
#[serde(rename = "FileSystemConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_system_configs: Option<Vec<FileSystemConfig>>,
#[serde(rename = "FunctionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_arn: Option<String>,
#[serde(rename = "FunctionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_name: Option<String>,
#[serde(rename = "Handler")]
#[serde(skip_serializing_if = "Option::is_none")]
pub handler: Option<String>,
#[serde(rename = "ImageConfigResponse")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_config_response: Option<ImageConfigResponse>,
#[serde(rename = "KMSKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_arn: Option<String>,
#[serde(rename = "LastModified")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified: Option<String>,
#[serde(rename = "LastUpdateStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_status: Option<String>,
#[serde(rename = "LastUpdateStatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_status_reason: Option<String>,
#[serde(rename = "LastUpdateStatusReasonCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_update_status_reason_code: Option<String>,
#[serde(rename = "Layers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layers: Option<Vec<Layer>>,
#[serde(rename = "MasterArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_arn: Option<String>,
#[serde(rename = "MemorySize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub memory_size: Option<i64>,
#[serde(rename = "PackageType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub package_type: Option<String>,
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "Role")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role: Option<String>,
#[serde(rename = "Runtime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub runtime: Option<String>,
#[serde(rename = "SigningJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_job_arn: Option<String>,
#[serde(rename = "SigningProfileVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_profile_version_arn: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
#[serde(rename = "StateReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_reason: Option<String>,
#[serde(rename = "StateReasonCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state_reason_code: Option<String>,
#[serde(rename = "Timeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<i64>,
#[serde(rename = "TracingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracing_config: Option<TracingConfigResponse>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<String>,
#[serde(rename = "VpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VpcConfigResponse>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FunctionEventInvokeConfig {
#[serde(rename = "DestinationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_config: Option<DestinationConfig>,
#[serde(rename = "FunctionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_arn: Option<String>,
#[serde(rename = "LastModified")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified: Option<f64>,
#[serde(rename = "MaximumEventAgeInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_event_age_in_seconds: Option<i64>,
#[serde(rename = "MaximumRetryAttempts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_retry_attempts: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAccountSettingsRequest {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAccountSettingsResponse {
#[serde(rename = "AccountLimit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_limit: Option<AccountLimit>,
#[serde(rename = "AccountUsage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_usage: Option<AccountUsage>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAliasRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCodeSigningConfigRequest {
#[serde(rename = "CodeSigningConfigArn")]
pub code_signing_config_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCodeSigningConfigResponse {
#[serde(rename = "CodeSigningConfig")]
pub code_signing_config: CodeSigningConfig,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetEventSourceMappingRequest {
#[serde(rename = "UUID")]
pub uuid: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFunctionCodeSigningConfigRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFunctionCodeSigningConfigResponse {
#[serde(rename = "CodeSigningConfigArn")]
pub code_signing_config_arn: String,
#[serde(rename = "FunctionName")]
pub function_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFunctionConcurrencyRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFunctionConcurrencyResponse {
#[serde(rename = "ReservedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reserved_concurrent_executions: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFunctionConfigurationRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Qualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFunctionEventInvokeConfigRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Qualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFunctionRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Qualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifier: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFunctionResponse {
#[serde(rename = "Code")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code: Option<FunctionCodeLocation>,
#[serde(rename = "Concurrency")]
#[serde(skip_serializing_if = "Option::is_none")]
pub concurrency: Option<Concurrency>,
#[serde(rename = "Configuration")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration: Option<FunctionConfiguration>,
#[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 GetLayerVersionByArnRequest {
#[serde(rename = "Arn")]
pub arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLayerVersionPolicyRequest {
#[serde(rename = "LayerName")]
pub layer_name: String,
#[serde(rename = "VersionNumber")]
pub version_number: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLayerVersionPolicyResponse {
#[serde(rename = "Policy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy: Option<String>,
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLayerVersionRequest {
#[serde(rename = "LayerName")]
pub layer_name: String,
#[serde(rename = "VersionNumber")]
pub version_number: i64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLayerVersionResponse {
#[serde(rename = "CompatibleRuntimes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_runtimes: Option<Vec<String>>,
#[serde(rename = "Content")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content: Option<LayerVersionContentOutput>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LayerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_arn: Option<String>,
#[serde(rename = "LayerVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_version_arn: Option<String>,
#[serde(rename = "LicenseInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_info: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetPolicyRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Qualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifier: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetPolicyResponse {
#[serde(rename = "Policy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy: Option<String>,
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetProvisionedConcurrencyConfigRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Qualifier")]
pub qualifier: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetProvisionedConcurrencyConfigResponse {
#[serde(rename = "AllocatedProvisionedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_provisioned_concurrent_executions: Option<i64>,
#[serde(rename = "AvailableProvisionedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub available_provisioned_concurrent_executions: Option<i64>,
#[serde(rename = "LastModified")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified: Option<String>,
#[serde(rename = "RequestedProvisionedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_provisioned_concurrent_executions: Option<i64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_reason: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ImageConfig {
#[serde(rename = "Command")]
#[serde(skip_serializing_if = "Option::is_none")]
pub command: Option<Vec<String>>,
#[serde(rename = "EntryPoint")]
#[serde(skip_serializing_if = "Option::is_none")]
pub entry_point: Option<Vec<String>>,
#[serde(rename = "WorkingDirectory")]
#[serde(skip_serializing_if = "Option::is_none")]
pub working_directory: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImageConfigError {
#[serde(rename = "ErrorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ImageConfigResponse {
#[serde(rename = "Error")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error: Option<ImageConfigError>,
#[serde(rename = "ImageConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_config: Option<ImageConfig>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InvocationRequest {
#[serde(rename = "ClientContext")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_context: Option<String>,
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "InvocationType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub invocation_type: Option<String>,
#[serde(rename = "LogType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_type: Option<String>,
#[serde(rename = "Payload")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub payload: Option<bytes::Bytes>,
#[serde(rename = "Qualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq)]
pub struct InvocationResponse {
pub executed_version: Option<String>,
pub function_error: Option<String>,
pub log_result: Option<String>,
pub payload: Option<bytes::Bytes>,
pub status_code: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct InvokeAsyncRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "InvokeArgs")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub invoke_args: bytes::Bytes,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct InvokeAsyncResponse {
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Layer {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "CodeSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_size: Option<i64>,
#[serde(rename = "SigningJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_job_arn: Option<String>,
#[serde(rename = "SigningProfileVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_profile_version_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LayerVersionContentInput {
#[serde(rename = "S3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_bucket: Option<String>,
#[serde(rename = "S3Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_key: Option<String>,
#[serde(rename = "S3ObjectVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_object_version: Option<String>,
#[serde(rename = "ZipFile")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub zip_file: Option<bytes::Bytes>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LayerVersionContentOutput {
#[serde(rename = "CodeSha256")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_sha_256: Option<String>,
#[serde(rename = "CodeSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_size: Option<i64>,
#[serde(rename = "Location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<String>,
#[serde(rename = "SigningJobArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_job_arn: Option<String>,
#[serde(rename = "SigningProfileVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub signing_profile_version_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LayerVersionsListItem {
#[serde(rename = "CompatibleRuntimes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_runtimes: Option<Vec<String>>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LayerVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_version_arn: Option<String>,
#[serde(rename = "LicenseInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_info: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LayersListItem {
#[serde(rename = "LatestMatchingVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub latest_matching_version: Option<LayerVersionsListItem>,
#[serde(rename = "LayerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_arn: Option<String>,
#[serde(rename = "LayerName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAliasesRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "FunctionVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_version: Option<String>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAliasesResponse {
#[serde(rename = "Aliases")]
#[serde(skip_serializing_if = "Option::is_none")]
pub aliases: Option<Vec<AliasConfiguration>>,
#[serde(rename = "NextMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_marker: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListCodeSigningConfigsRequest {
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListCodeSigningConfigsResponse {
#[serde(rename = "CodeSigningConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_signing_configs: Option<Vec<CodeSigningConfig>>,
#[serde(rename = "NextMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_marker: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListEventSourceMappingsRequest {
#[serde(rename = "EventSourceArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_source_arn: Option<String>,
#[serde(rename = "FunctionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_name: Option<String>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListEventSourceMappingsResponse {
#[serde(rename = "EventSourceMappings")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_source_mappings: Option<Vec<EventSourceMappingConfiguration>>,
#[serde(rename = "NextMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_marker: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFunctionEventInvokeConfigsRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFunctionEventInvokeConfigsResponse {
#[serde(rename = "FunctionEventInvokeConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_event_invoke_configs: Option<Vec<FunctionEventInvokeConfig>>,
#[serde(rename = "NextMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_marker: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFunctionsByCodeSigningConfigRequest {
#[serde(rename = "CodeSigningConfigArn")]
pub code_signing_config_arn: String,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFunctionsByCodeSigningConfigResponse {
#[serde(rename = "FunctionArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_arns: Option<Vec<String>>,
#[serde(rename = "NextMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_marker: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListFunctionsRequest {
#[serde(rename = "FunctionVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_version: Option<String>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MasterRegion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub master_region: Option<String>,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: Option<i64>,
}
#[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 = "NextMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_marker: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLayerVersionsRequest {
#[serde(rename = "CompatibleRuntime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_runtime: Option<String>,
#[serde(rename = "LayerName")]
pub layer_name: String,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLayerVersionsResponse {
#[serde(rename = "LayerVersions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_versions: Option<Vec<LayerVersionsListItem>>,
#[serde(rename = "NextMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_marker: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListLayersRequest {
#[serde(rename = "CompatibleRuntime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_runtime: Option<String>,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListLayersResponse {
#[serde(rename = "Layers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layers: Option<Vec<LayersListItem>>,
#[serde(rename = "NextMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_marker: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListProvisionedConcurrencyConfigsRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListProvisionedConcurrencyConfigsResponse {
#[serde(rename = "NextMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_marker: Option<String>,
#[serde(rename = "ProvisionedConcurrencyConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub provisioned_concurrency_configs: Option<Vec<ProvisionedConcurrencyConfigListItem>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsRequest {
#[serde(rename = "Resource")]
pub resource: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsResponse {
#[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 ListVersionsByFunctionRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Marker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub marker: Option<String>,
#[serde(rename = "MaxItems")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_items: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListVersionsByFunctionResponse {
#[serde(rename = "NextMarker")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_marker: Option<String>,
#[serde(rename = "Versions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub versions: Option<Vec<FunctionConfiguration>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OnFailure {
#[serde(rename = "Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct OnSuccess {
#[serde(rename = "Destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProvisionedConcurrencyConfigListItem {
#[serde(rename = "AllocatedProvisionedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_provisioned_concurrent_executions: Option<i64>,
#[serde(rename = "AvailableProvisionedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub available_provisioned_concurrent_executions: Option<i64>,
#[serde(rename = "FunctionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_arn: Option<String>,
#[serde(rename = "LastModified")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified: Option<String>,
#[serde(rename = "RequestedProvisionedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_provisioned_concurrent_executions: Option<i64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_reason: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PublishLayerVersionRequest {
#[serde(rename = "CompatibleRuntimes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_runtimes: Option<Vec<String>>,
#[serde(rename = "Content")]
pub content: LayerVersionContentInput,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LayerName")]
pub layer_name: String,
#[serde(rename = "LicenseInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_info: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PublishLayerVersionResponse {
#[serde(rename = "CompatibleRuntimes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub compatible_runtimes: Option<Vec<String>>,
#[serde(rename = "Content")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content: Option<LayerVersionContentOutput>,
#[serde(rename = "CreatedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub created_date: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "LayerArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_arn: Option<String>,
#[serde(rename = "LayerVersionArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layer_version_arn: Option<String>,
#[serde(rename = "LicenseInfo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub license_info: Option<String>,
#[serde(rename = "Version")]
#[serde(skip_serializing_if = "Option::is_none")]
pub version: Option<i64>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PublishVersionRequest {
#[serde(rename = "CodeSha256")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_sha_256: Option<String>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutFunctionCodeSigningConfigRequest {
#[serde(rename = "CodeSigningConfigArn")]
pub code_signing_config_arn: String,
#[serde(rename = "FunctionName")]
pub function_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutFunctionCodeSigningConfigResponse {
#[serde(rename = "CodeSigningConfigArn")]
pub code_signing_config_arn: String,
#[serde(rename = "FunctionName")]
pub function_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutFunctionConcurrencyRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "ReservedConcurrentExecutions")]
pub reserved_concurrent_executions: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutFunctionEventInvokeConfigRequest {
#[serde(rename = "DestinationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_config: Option<DestinationConfig>,
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "MaximumEventAgeInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_event_age_in_seconds: Option<i64>,
#[serde(rename = "MaximumRetryAttempts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_retry_attempts: Option<i64>,
#[serde(rename = "Qualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutProvisionedConcurrencyConfigRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "ProvisionedConcurrentExecutions")]
pub provisioned_concurrent_executions: i64,
#[serde(rename = "Qualifier")]
pub qualifier: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutProvisionedConcurrencyConfigResponse {
#[serde(rename = "AllocatedProvisionedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allocated_provisioned_concurrent_executions: Option<i64>,
#[serde(rename = "AvailableProvisionedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub available_provisioned_concurrent_executions: Option<i64>,
#[serde(rename = "LastModified")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified: Option<String>,
#[serde(rename = "RequestedProvisionedConcurrentExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub requested_provisioned_concurrent_executions: Option<i64>,
#[serde(rename = "Status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "StatusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_reason: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveLayerVersionPermissionRequest {
#[serde(rename = "LayerName")]
pub layer_name: String,
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "StatementId")]
pub statement_id: String,
#[serde(rename = "VersionNumber")]
pub version_number: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemovePermissionRequest {
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Qualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifier: Option<String>,
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "StatementId")]
pub statement_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SelfManagedEventSource {
#[serde(rename = "Endpoints")]
#[serde(skip_serializing_if = "Option::is_none")]
pub endpoints: Option<::std::collections::HashMap<String, Vec<String>>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SourceAccessConfiguration {
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
#[serde(rename = "URI")]
#[serde(skip_serializing_if = "Option::is_none")]
pub uri: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "Resource")]
pub resource: String,
#[serde(rename = "Tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TracingConfig {
#[serde(rename = "Mode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mode: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TracingConfigResponse {
#[serde(rename = "Mode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mode: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "Resource")]
pub resource: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAliasRequest {
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "FunctionVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_version: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "RoutingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub routing_config: Option<AliasRoutingConfiguration>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateCodeSigningConfigRequest {
#[serde(rename = "AllowedPublishers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub allowed_publishers: Option<AllowedPublishers>,
#[serde(rename = "CodeSigningConfigArn")]
pub code_signing_config_arn: String,
#[serde(rename = "CodeSigningPolicies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub code_signing_policies: Option<CodeSigningPolicies>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateCodeSigningConfigResponse {
#[serde(rename = "CodeSigningConfig")]
pub code_signing_config: CodeSigningConfig,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateEventSourceMappingRequest {
#[serde(rename = "BatchSize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_size: Option<i64>,
#[serde(rename = "BisectBatchOnFunctionError")]
#[serde(skip_serializing_if = "Option::is_none")]
pub bisect_batch_on_function_error: Option<bool>,
#[serde(rename = "DestinationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_config: Option<DestinationConfig>,
#[serde(rename = "Enabled")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enabled: Option<bool>,
#[serde(rename = "FunctionName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_name: Option<String>,
#[serde(rename = "FunctionResponseTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub function_response_types: Option<Vec<String>>,
#[serde(rename = "MaximumBatchingWindowInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_batching_window_in_seconds: Option<i64>,
#[serde(rename = "MaximumRecordAgeInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_record_age_in_seconds: Option<i64>,
#[serde(rename = "MaximumRetryAttempts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_retry_attempts: Option<i64>,
#[serde(rename = "ParallelizationFactor")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parallelization_factor: Option<i64>,
#[serde(rename = "SourceAccessConfigurations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_access_configurations: Option<Vec<SourceAccessConfiguration>>,
#[serde(rename = "TumblingWindowInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tumbling_window_in_seconds: Option<i64>,
#[serde(rename = "UUID")]
pub uuid: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFunctionCodeRequest {
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "ImageUri")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_uri: Option<String>,
#[serde(rename = "Publish")]
#[serde(skip_serializing_if = "Option::is_none")]
pub publish: Option<bool>,
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "S3Bucket")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_bucket: Option<String>,
#[serde(rename = "S3Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_key: Option<String>,
#[serde(rename = "S3ObjectVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub s3_object_version: Option<String>,
#[serde(rename = "ZipFile")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub zip_file: Option<bytes::Bytes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFunctionConfigurationRequest {
#[serde(rename = "DeadLetterConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dead_letter_config: Option<DeadLetterConfig>,
#[serde(rename = "Description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "Environment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment: Option<Environment>,
#[serde(rename = "FileSystemConfigs")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_system_configs: Option<Vec<FileSystemConfig>>,
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "Handler")]
#[serde(skip_serializing_if = "Option::is_none")]
pub handler: Option<String>,
#[serde(rename = "ImageConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub image_config: Option<ImageConfig>,
#[serde(rename = "KMSKeyArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub kms_key_arn: Option<String>,
#[serde(rename = "Layers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub layers: Option<Vec<String>>,
#[serde(rename = "MemorySize")]
#[serde(skip_serializing_if = "Option::is_none")]
pub memory_size: Option<i64>,
#[serde(rename = "RevisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "Role")]
#[serde(skip_serializing_if = "Option::is_none")]
pub role: Option<String>,
#[serde(rename = "Runtime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub runtime: Option<String>,
#[serde(rename = "Timeout")]
#[serde(skip_serializing_if = "Option::is_none")]
pub timeout: Option<i64>,
#[serde(rename = "TracingConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tracing_config: Option<TracingConfig>,
#[serde(rename = "VpcConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_config: Option<VpcConfig>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFunctionEventInvokeConfigRequest {
#[serde(rename = "DestinationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_config: Option<DestinationConfig>,
#[serde(rename = "FunctionName")]
pub function_name: String,
#[serde(rename = "MaximumEventAgeInSeconds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_event_age_in_seconds: Option<i64>,
#[serde(rename = "MaximumRetryAttempts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub maximum_retry_attempts: Option<i64>,
#[serde(rename = "Qualifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub qualifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct VpcConfig {
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct VpcConfigResponse {
#[serde(rename = "SecurityGroupIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub security_group_ids: Option<Vec<String>>,
#[serde(rename = "SubnetIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub subnet_ids: Option<Vec<String>>,
#[serde(rename = "VpcId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub vpc_id: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AddLayerVersionPermissionError {
InvalidParameterValue(String),
PolicyLengthExceeded(String),
PreconditionFailed(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl AddLayerVersionPermissionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddLayerVersionPermissionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
AddLayerVersionPermissionError::InvalidParameterValue(err.msg),
)
}
"PolicyLengthExceededException" => {
return RusotoError::Service(
AddLayerVersionPermissionError::PolicyLengthExceeded(err.msg),
)
}
"PreconditionFailedException" => {
return RusotoError::Service(
AddLayerVersionPermissionError::PreconditionFailed(err.msg),
)
}
"ResourceConflictException" => {
return RusotoError::Service(AddLayerVersionPermissionError::ResourceConflict(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AddLayerVersionPermissionError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(AddLayerVersionPermissionError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AddLayerVersionPermissionError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddLayerVersionPermissionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddLayerVersionPermissionError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
AddLayerVersionPermissionError::PolicyLengthExceeded(ref cause) => {
write!(f, "{}", cause)
}
AddLayerVersionPermissionError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
AddLayerVersionPermissionError::ResourceConflict(ref cause) => write!(f, "{}", cause),
AddLayerVersionPermissionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AddLayerVersionPermissionError::Service(ref cause) => write!(f, "{}", cause),
AddLayerVersionPermissionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddLayerVersionPermissionError {}
#[derive(Debug, PartialEq)]
pub enum AddPermissionError {
InvalidParameterValue(String),
PolicyLengthExceeded(String),
PreconditionFailed(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl AddPermissionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddPermissionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(AddPermissionError::InvalidParameterValue(err.msg))
}
"PolicyLengthExceededException" => {
return RusotoError::Service(AddPermissionError::PolicyLengthExceeded(err.msg))
}
"PreconditionFailedException" => {
return RusotoError::Service(AddPermissionError::PreconditionFailed(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(AddPermissionError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AddPermissionError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(AddPermissionError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(AddPermissionError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddPermissionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddPermissionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
AddPermissionError::PolicyLengthExceeded(ref cause) => write!(f, "{}", cause),
AddPermissionError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
AddPermissionError::ResourceConflict(ref cause) => write!(f, "{}", cause),
AddPermissionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AddPermissionError::Service(ref cause) => write!(f, "{}", cause),
AddPermissionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddPermissionError {}
#[derive(Debug, PartialEq)]
pub enum CreateAliasError {
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl CreateAliasError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAliasError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(CreateAliasError::InvalidParameterValue(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(CreateAliasError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateAliasError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateAliasError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateAliasError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateAliasError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateAliasError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateAliasError::ResourceConflict(ref cause) => write!(f, "{}", cause),
CreateAliasError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateAliasError::Service(ref cause) => write!(f, "{}", cause),
CreateAliasError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateAliasError {}
#[derive(Debug, PartialEq)]
pub enum CreateCodeSigningConfigError {
InvalidParameterValue(String),
Service(String),
}
impl CreateCodeSigningConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCodeSigningConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
CreateCodeSigningConfigError::InvalidParameterValue(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(CreateCodeSigningConfigError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCodeSigningConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCodeSigningConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
CreateCodeSigningConfigError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateCodeSigningConfigError {}
#[derive(Debug, PartialEq)]
pub enum CreateEventSourceMappingError {
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl CreateEventSourceMappingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateEventSourceMappingError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
CreateEventSourceMappingError::InvalidParameterValue(err.msg),
)
}
"ResourceConflictException" => {
return RusotoError::Service(CreateEventSourceMappingError::ResourceConflict(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateEventSourceMappingError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(CreateEventSourceMappingError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateEventSourceMappingError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateEventSourceMappingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateEventSourceMappingError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
CreateEventSourceMappingError::ResourceConflict(ref cause) => write!(f, "{}", cause),
CreateEventSourceMappingError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateEventSourceMappingError::Service(ref cause) => write!(f, "{}", cause),
CreateEventSourceMappingError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateEventSourceMappingError {}
#[derive(Debug, PartialEq)]
pub enum CreateFunctionError {
CodeSigningConfigNotFound(String),
CodeStorageExceeded(String),
CodeVerificationFailed(String),
InvalidCodeSignature(String),
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(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() {
"CodeSigningConfigNotFoundException" => {
return RusotoError::Service(CreateFunctionError::CodeSigningConfigNotFound(
err.msg,
))
}
"CodeStorageExceededException" => {
return RusotoError::Service(CreateFunctionError::CodeStorageExceeded(err.msg))
}
"CodeVerificationFailedException" => {
return RusotoError::Service(CreateFunctionError::CodeVerificationFailed(
err.msg,
))
}
"InvalidCodeSignatureException" => {
return RusotoError::Service(CreateFunctionError::InvalidCodeSignature(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(CreateFunctionError::InvalidParameterValue(
err.msg,
))
}
"ResourceConflictException" => {
return RusotoError::Service(CreateFunctionError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateFunctionError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(CreateFunctionError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(CreateFunctionError::TooManyRequests(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::CodeSigningConfigNotFound(ref cause) => write!(f, "{}", cause),
CreateFunctionError::CodeStorageExceeded(ref cause) => write!(f, "{}", cause),
CreateFunctionError::CodeVerificationFailed(ref cause) => write!(f, "{}", cause),
CreateFunctionError::InvalidCodeSignature(ref cause) => write!(f, "{}", cause),
CreateFunctionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
CreateFunctionError::ResourceConflict(ref cause) => write!(f, "{}", cause),
CreateFunctionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateFunctionError::Service(ref cause) => write!(f, "{}", cause),
CreateFunctionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFunctionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAliasError {
InvalidParameterValue(String),
ResourceConflict(String),
Service(String),
TooManyRequests(String),
}
impl DeleteAliasError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAliasError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(DeleteAliasError::InvalidParameterValue(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(DeleteAliasError::ResourceConflict(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteAliasError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteAliasError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAliasError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAliasError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteAliasError::ResourceConflict(ref cause) => write!(f, "{}", cause),
DeleteAliasError::Service(ref cause) => write!(f, "{}", cause),
DeleteAliasError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAliasError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCodeSigningConfigError {
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
}
impl DeleteCodeSigningConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCodeSigningConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
DeleteCodeSigningConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceConflictException" => {
return RusotoError::Service(DeleteCodeSigningConfigError::ResourceConflict(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteCodeSigningConfigError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteCodeSigningConfigError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteCodeSigningConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCodeSigningConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteCodeSigningConfigError::ResourceConflict(ref cause) => write!(f, "{}", cause),
DeleteCodeSigningConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteCodeSigningConfigError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteCodeSigningConfigError {}
#[derive(Debug, PartialEq)]
pub enum DeleteEventSourceMappingError {
InvalidParameterValue(String),
ResourceInUse(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl DeleteEventSourceMappingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteEventSourceMappingError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
DeleteEventSourceMappingError::InvalidParameterValue(err.msg),
)
}
"ResourceInUseException" => {
return RusotoError::Service(DeleteEventSourceMappingError::ResourceInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteEventSourceMappingError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteEventSourceMappingError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteEventSourceMappingError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteEventSourceMappingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteEventSourceMappingError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteEventSourceMappingError::ResourceInUse(ref cause) => write!(f, "{}", cause),
DeleteEventSourceMappingError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteEventSourceMappingError::Service(ref cause) => write!(f, "{}", cause),
DeleteEventSourceMappingError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteEventSourceMappingError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFunctionError {
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(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() {
"InvalidParameterValueException" => {
return RusotoError::Service(DeleteFunctionError::InvalidParameterValue(
err.msg,
))
}
"ResourceConflictException" => {
return RusotoError::Service(DeleteFunctionError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteFunctionError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(DeleteFunctionError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteFunctionError::TooManyRequests(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::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
DeleteFunctionError::ResourceConflict(ref cause) => write!(f, "{}", cause),
DeleteFunctionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteFunctionError::Service(ref cause) => write!(f, "{}", cause),
DeleteFunctionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFunctionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFunctionCodeSigningConfigError {
CodeSigningConfigNotFound(String),
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl DeleteFunctionCodeSigningConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteFunctionCodeSigningConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CodeSigningConfigNotFoundException" => {
return RusotoError::Service(
DeleteFunctionCodeSigningConfigError::CodeSigningConfigNotFound(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
DeleteFunctionCodeSigningConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceConflictException" => {
return RusotoError::Service(
DeleteFunctionCodeSigningConfigError::ResourceConflict(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteFunctionCodeSigningConfigError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(DeleteFunctionCodeSigningConfigError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
DeleteFunctionCodeSigningConfigError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFunctionCodeSigningConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFunctionCodeSigningConfigError::CodeSigningConfigNotFound(ref cause) => {
write!(f, "{}", cause)
}
DeleteFunctionCodeSigningConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteFunctionCodeSigningConfigError::ResourceConflict(ref cause) => {
write!(f, "{}", cause)
}
DeleteFunctionCodeSigningConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DeleteFunctionCodeSigningConfigError::Service(ref cause) => write!(f, "{}", cause),
DeleteFunctionCodeSigningConfigError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteFunctionCodeSigningConfigError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFunctionConcurrencyError {
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl DeleteFunctionConcurrencyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFunctionConcurrencyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
DeleteFunctionConcurrencyError::InvalidParameterValue(err.msg),
)
}
"ResourceConflictException" => {
return RusotoError::Service(DeleteFunctionConcurrencyError::ResourceConflict(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteFunctionConcurrencyError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(DeleteFunctionConcurrencyError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteFunctionConcurrencyError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFunctionConcurrencyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFunctionConcurrencyError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteFunctionConcurrencyError::ResourceConflict(ref cause) => write!(f, "{}", cause),
DeleteFunctionConcurrencyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteFunctionConcurrencyError::Service(ref cause) => write!(f, "{}", cause),
DeleteFunctionConcurrencyError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFunctionConcurrencyError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFunctionEventInvokeConfigError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl DeleteFunctionEventInvokeConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteFunctionEventInvokeConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
DeleteFunctionEventInvokeConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteFunctionEventInvokeConfigError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(DeleteFunctionEventInvokeConfigError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
DeleteFunctionEventInvokeConfigError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFunctionEventInvokeConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFunctionEventInvokeConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteFunctionEventInvokeConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DeleteFunctionEventInvokeConfigError::Service(ref cause) => write!(f, "{}", cause),
DeleteFunctionEventInvokeConfigError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteFunctionEventInvokeConfigError {}
#[derive(Debug, PartialEq)]
pub enum DeleteLayerVersionError {
Service(String),
TooManyRequests(String),
}
impl DeleteLayerVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteLayerVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ServiceException" => {
return RusotoError::Service(DeleteLayerVersionError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(DeleteLayerVersionError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteLayerVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteLayerVersionError::Service(ref cause) => write!(f, "{}", cause),
DeleteLayerVersionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteLayerVersionError {}
#[derive(Debug, PartialEq)]
pub enum DeleteProvisionedConcurrencyConfigError {
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl DeleteProvisionedConcurrencyConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteProvisionedConcurrencyConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
DeleteProvisionedConcurrencyConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceConflictException" => {
return RusotoError::Service(
DeleteProvisionedConcurrencyConfigError::ResourceConflict(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
DeleteProvisionedConcurrencyConfigError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(DeleteProvisionedConcurrencyConfigError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
DeleteProvisionedConcurrencyConfigError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteProvisionedConcurrencyConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteProvisionedConcurrencyConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
DeleteProvisionedConcurrencyConfigError::ResourceConflict(ref cause) => {
write!(f, "{}", cause)
}
DeleteProvisionedConcurrencyConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
DeleteProvisionedConcurrencyConfigError::Service(ref cause) => write!(f, "{}", cause),
DeleteProvisionedConcurrencyConfigError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteProvisionedConcurrencyConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetAccountSettingsError {
Service(String),
TooManyRequests(String),
}
impl GetAccountSettingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAccountSettingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"ServiceException" => {
return RusotoError::Service(GetAccountSettingsError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetAccountSettingsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAccountSettingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAccountSettingsError::Service(ref cause) => write!(f, "{}", cause),
GetAccountSettingsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAccountSettingsError {}
#[derive(Debug, PartialEq)]
pub enum GetAliasError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl GetAliasError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAliasError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(GetAliasError::InvalidParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetAliasError::ResourceNotFound(err.msg))
}
"ServiceException" => return RusotoError::Service(GetAliasError::Service(err.msg)),
"TooManyRequestsException" => {
return RusotoError::Service(GetAliasError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAliasError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAliasError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetAliasError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetAliasError::Service(ref cause) => write!(f, "{}", cause),
GetAliasError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAliasError {}
#[derive(Debug, PartialEq)]
pub enum GetCodeSigningConfigError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
}
impl GetCodeSigningConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCodeSigningConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(GetCodeSigningConfigError::InvalidParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetCodeSigningConfigError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetCodeSigningConfigError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCodeSigningConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCodeSigningConfigError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetCodeSigningConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetCodeSigningConfigError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCodeSigningConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetEventSourceMappingError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl GetEventSourceMappingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetEventSourceMappingError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(GetEventSourceMappingError::InvalidParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetEventSourceMappingError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetEventSourceMappingError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetEventSourceMappingError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetEventSourceMappingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetEventSourceMappingError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetEventSourceMappingError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetEventSourceMappingError::Service(ref cause) => write!(f, "{}", cause),
GetEventSourceMappingError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetEventSourceMappingError {}
#[derive(Debug, PartialEq)]
pub enum GetFunctionError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(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() {
"InvalidParameterValueException" => {
return RusotoError::Service(GetFunctionError::InvalidParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetFunctionError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetFunctionError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetFunctionError::TooManyRequests(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::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetFunctionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetFunctionError::Service(ref cause) => write!(f, "{}", cause),
GetFunctionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFunctionError {}
#[derive(Debug, PartialEq)]
pub enum GetFunctionCodeSigningConfigError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl GetFunctionCodeSigningConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetFunctionCodeSigningConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
GetFunctionCodeSigningConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetFunctionCodeSigningConfigError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetFunctionCodeSigningConfigError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
GetFunctionCodeSigningConfigError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFunctionCodeSigningConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFunctionCodeSigningConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetFunctionCodeSigningConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetFunctionCodeSigningConfigError::Service(ref cause) => write!(f, "{}", cause),
GetFunctionCodeSigningConfigError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFunctionCodeSigningConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetFunctionConcurrencyError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl GetFunctionConcurrencyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFunctionConcurrencyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
GetFunctionConcurrencyError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetFunctionConcurrencyError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetFunctionConcurrencyError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetFunctionConcurrencyError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFunctionConcurrencyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFunctionConcurrencyError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetFunctionConcurrencyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetFunctionConcurrencyError::Service(ref cause) => write!(f, "{}", cause),
GetFunctionConcurrencyError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFunctionConcurrencyError {}
#[derive(Debug, PartialEq)]
pub enum GetFunctionConfigurationError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl GetFunctionConfigurationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFunctionConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
GetFunctionConfigurationError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetFunctionConfigurationError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetFunctionConfigurationError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetFunctionConfigurationError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFunctionConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFunctionConfigurationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetFunctionConfigurationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetFunctionConfigurationError::Service(ref cause) => write!(f, "{}", cause),
GetFunctionConfigurationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFunctionConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum GetFunctionEventInvokeConfigError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl GetFunctionEventInvokeConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetFunctionEventInvokeConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
GetFunctionEventInvokeConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetFunctionEventInvokeConfigError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetFunctionEventInvokeConfigError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
GetFunctionEventInvokeConfigError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFunctionEventInvokeConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFunctionEventInvokeConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetFunctionEventInvokeConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetFunctionEventInvokeConfigError::Service(ref cause) => write!(f, "{}", cause),
GetFunctionEventInvokeConfigError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFunctionEventInvokeConfigError {}
#[derive(Debug, PartialEq)]
pub enum GetLayerVersionError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl GetLayerVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLayerVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(GetLayerVersionError::InvalidParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetLayerVersionError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetLayerVersionError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetLayerVersionError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLayerVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLayerVersionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetLayerVersionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetLayerVersionError::Service(ref cause) => write!(f, "{}", cause),
GetLayerVersionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLayerVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetLayerVersionByArnError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl GetLayerVersionByArnError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLayerVersionByArnError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(GetLayerVersionByArnError::InvalidParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetLayerVersionByArnError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetLayerVersionByArnError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetLayerVersionByArnError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLayerVersionByArnError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLayerVersionByArnError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetLayerVersionByArnError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetLayerVersionByArnError::Service(ref cause) => write!(f, "{}", cause),
GetLayerVersionByArnError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLayerVersionByArnError {}
#[derive(Debug, PartialEq)]
pub enum GetLayerVersionPolicyError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl GetLayerVersionPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLayerVersionPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(GetLayerVersionPolicyError::InvalidParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetLayerVersionPolicyError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(GetLayerVersionPolicyError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetLayerVersionPolicyError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLayerVersionPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLayerVersionPolicyError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetLayerVersionPolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetLayerVersionPolicyError::Service(ref cause) => write!(f, "{}", cause),
GetLayerVersionPolicyError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLayerVersionPolicyError {}
#[derive(Debug, PartialEq)]
pub enum GetPolicyError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl GetPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(GetPolicyError::InvalidParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetPolicyError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(GetPolicyError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(GetPolicyError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetPolicyError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
GetPolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetPolicyError::Service(ref cause) => write!(f, "{}", cause),
GetPolicyError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetPolicyError {}
#[derive(Debug, PartialEq)]
pub enum GetProvisionedConcurrencyConfigError {
InvalidParameterValue(String),
ProvisionedConcurrencyConfigNotFound(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl GetProvisionedConcurrencyConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetProvisionedConcurrencyConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
GetProvisionedConcurrencyConfigError::InvalidParameterValue(err.msg),
)
}
"ProvisionedConcurrencyConfigNotFoundException" => {
return RusotoError::Service(
GetProvisionedConcurrencyConfigError::ProvisionedConcurrencyConfigNotFound(
err.msg,
),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetProvisionedConcurrencyConfigError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(GetProvisionedConcurrencyConfigError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
GetProvisionedConcurrencyConfigError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetProvisionedConcurrencyConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetProvisionedConcurrencyConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
GetProvisionedConcurrencyConfigError::ProvisionedConcurrencyConfigNotFound(
ref cause,
) => write!(f, "{}", cause),
GetProvisionedConcurrencyConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetProvisionedConcurrencyConfigError::Service(ref cause) => write!(f, "{}", cause),
GetProvisionedConcurrencyConfigError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetProvisionedConcurrencyConfigError {}
#[derive(Debug, PartialEq)]
pub enum InvokeError {
EC2AccessDenied(String),
EC2Throttled(String),
EC2Unexpected(String),
EFSIO(String),
EFSMountConnectivity(String),
EFSMountFailure(String),
EFSMountTimeout(String),
ENILimitReached(String),
InvalidParameterValue(String),
InvalidRequestContent(String),
InvalidRuntime(String),
InvalidSecurityGroupID(String),
InvalidSubnetID(String),
InvalidZipFile(String),
KMSAccessDenied(String),
KMSDisabled(String),
KMSInvalidState(String),
KMSNotFound(String),
RequestTooLarge(String),
ResourceConflict(String),
ResourceNotFound(String),
ResourceNotReady(String),
Service(String),
SubnetIPAddressLimitReached(String),
TooManyRequests(String),
UnsupportedMediaType(String),
}
impl InvokeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<InvokeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"EC2AccessDeniedException" => {
return RusotoError::Service(InvokeError::EC2AccessDenied(err.msg))
}
"EC2ThrottledException" => {
return RusotoError::Service(InvokeError::EC2Throttled(err.msg))
}
"EC2UnexpectedException" => {
return RusotoError::Service(InvokeError::EC2Unexpected(err.msg))
}
"EFSIOException" => return RusotoError::Service(InvokeError::EFSIO(err.msg)),
"EFSMountConnectivityException" => {
return RusotoError::Service(InvokeError::EFSMountConnectivity(err.msg))
}
"EFSMountFailureException" => {
return RusotoError::Service(InvokeError::EFSMountFailure(err.msg))
}
"EFSMountTimeoutException" => {
return RusotoError::Service(InvokeError::EFSMountTimeout(err.msg))
}
"ENILimitReachedException" => {
return RusotoError::Service(InvokeError::ENILimitReached(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(InvokeError::InvalidParameterValue(err.msg))
}
"InvalidRequestContentException" => {
return RusotoError::Service(InvokeError::InvalidRequestContent(err.msg))
}
"InvalidRuntimeException" => {
return RusotoError::Service(InvokeError::InvalidRuntime(err.msg))
}
"InvalidSecurityGroupIDException" => {
return RusotoError::Service(InvokeError::InvalidSecurityGroupID(err.msg))
}
"InvalidSubnetIDException" => {
return RusotoError::Service(InvokeError::InvalidSubnetID(err.msg))
}
"InvalidZipFileException" => {
return RusotoError::Service(InvokeError::InvalidZipFile(err.msg))
}
"KMSAccessDeniedException" => {
return RusotoError::Service(InvokeError::KMSAccessDenied(err.msg))
}
"KMSDisabledException" => {
return RusotoError::Service(InvokeError::KMSDisabled(err.msg))
}
"KMSInvalidStateException" => {
return RusotoError::Service(InvokeError::KMSInvalidState(err.msg))
}
"KMSNotFoundException" => {
return RusotoError::Service(InvokeError::KMSNotFound(err.msg))
}
"RequestTooLargeException" => {
return RusotoError::Service(InvokeError::RequestTooLarge(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(InvokeError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(InvokeError::ResourceNotFound(err.msg))
}
"ResourceNotReadyException" => {
return RusotoError::Service(InvokeError::ResourceNotReady(err.msg))
}
"ServiceException" => return RusotoError::Service(InvokeError::Service(err.msg)),
"SubnetIPAddressLimitReachedException" => {
return RusotoError::Service(InvokeError::SubnetIPAddressLimitReached(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(InvokeError::TooManyRequests(err.msg))
}
"UnsupportedMediaTypeException" => {
return RusotoError::Service(InvokeError::UnsupportedMediaType(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for InvokeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InvokeError::EC2AccessDenied(ref cause) => write!(f, "{}", cause),
InvokeError::EC2Throttled(ref cause) => write!(f, "{}", cause),
InvokeError::EC2Unexpected(ref cause) => write!(f, "{}", cause),
InvokeError::EFSIO(ref cause) => write!(f, "{}", cause),
InvokeError::EFSMountConnectivity(ref cause) => write!(f, "{}", cause),
InvokeError::EFSMountFailure(ref cause) => write!(f, "{}", cause),
InvokeError::EFSMountTimeout(ref cause) => write!(f, "{}", cause),
InvokeError::ENILimitReached(ref cause) => write!(f, "{}", cause),
InvokeError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
InvokeError::InvalidRequestContent(ref cause) => write!(f, "{}", cause),
InvokeError::InvalidRuntime(ref cause) => write!(f, "{}", cause),
InvokeError::InvalidSecurityGroupID(ref cause) => write!(f, "{}", cause),
InvokeError::InvalidSubnetID(ref cause) => write!(f, "{}", cause),
InvokeError::InvalidZipFile(ref cause) => write!(f, "{}", cause),
InvokeError::KMSAccessDenied(ref cause) => write!(f, "{}", cause),
InvokeError::KMSDisabled(ref cause) => write!(f, "{}", cause),
InvokeError::KMSInvalidState(ref cause) => write!(f, "{}", cause),
InvokeError::KMSNotFound(ref cause) => write!(f, "{}", cause),
InvokeError::RequestTooLarge(ref cause) => write!(f, "{}", cause),
InvokeError::ResourceConflict(ref cause) => write!(f, "{}", cause),
InvokeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
InvokeError::ResourceNotReady(ref cause) => write!(f, "{}", cause),
InvokeError::Service(ref cause) => write!(f, "{}", cause),
InvokeError::SubnetIPAddressLimitReached(ref cause) => write!(f, "{}", cause),
InvokeError::TooManyRequests(ref cause) => write!(f, "{}", cause),
InvokeError::UnsupportedMediaType(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for InvokeError {}
#[derive(Debug, PartialEq)]
pub enum InvokeAsyncError {
InvalidRequestContent(String),
InvalidRuntime(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
}
impl InvokeAsyncError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<InvokeAsyncError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidRequestContentException" => {
return RusotoError::Service(InvokeAsyncError::InvalidRequestContent(err.msg))
}
"InvalidRuntimeException" => {
return RusotoError::Service(InvokeAsyncError::InvalidRuntime(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(InvokeAsyncError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(InvokeAsyncError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(InvokeAsyncError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for InvokeAsyncError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
InvokeAsyncError::InvalidRequestContent(ref cause) => write!(f, "{}", cause),
InvokeAsyncError::InvalidRuntime(ref cause) => write!(f, "{}", cause),
InvokeAsyncError::ResourceConflict(ref cause) => write!(f, "{}", cause),
InvokeAsyncError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
InvokeAsyncError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for InvokeAsyncError {}
#[derive(Debug, PartialEq)]
pub enum ListAliasesError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl ListAliasesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAliasesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListAliasesError::InvalidParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListAliasesError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListAliasesError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListAliasesError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAliasesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAliasesError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListAliasesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListAliasesError::Service(ref cause) => write!(f, "{}", cause),
ListAliasesError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListAliasesError {}
#[derive(Debug, PartialEq)]
pub enum ListCodeSigningConfigsError {
InvalidParameterValue(String),
Service(String),
}
impl ListCodeSigningConfigsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListCodeSigningConfigsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ListCodeSigningConfigsError::InvalidParameterValue(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(ListCodeSigningConfigsError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListCodeSigningConfigsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListCodeSigningConfigsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListCodeSigningConfigsError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListCodeSigningConfigsError {}
#[derive(Debug, PartialEq)]
pub enum ListEventSourceMappingsError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl ListEventSourceMappingsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListEventSourceMappingsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ListEventSourceMappingsError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListEventSourceMappingsError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(ListEventSourceMappingsError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListEventSourceMappingsError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListEventSourceMappingsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListEventSourceMappingsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListEventSourceMappingsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListEventSourceMappingsError::Service(ref cause) => write!(f, "{}", cause),
ListEventSourceMappingsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListEventSourceMappingsError {}
#[derive(Debug, PartialEq)]
pub enum ListFunctionEventInvokeConfigsError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl ListFunctionEventInvokeConfigsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListFunctionEventInvokeConfigsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ListFunctionEventInvokeConfigsError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListFunctionEventInvokeConfigsError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(ListFunctionEventInvokeConfigsError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
ListFunctionEventInvokeConfigsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFunctionEventInvokeConfigsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFunctionEventInvokeConfigsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListFunctionEventInvokeConfigsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListFunctionEventInvokeConfigsError::Service(ref cause) => write!(f, "{}", cause),
ListFunctionEventInvokeConfigsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListFunctionEventInvokeConfigsError {}
#[derive(Debug, PartialEq)]
pub enum ListFunctionsError {
InvalidParameterValue(String),
Service(String),
TooManyRequests(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() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListFunctionsError::InvalidParameterValue(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListFunctionsError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListFunctionsError::TooManyRequests(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::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListFunctionsError::Service(ref cause) => write!(f, "{}", cause),
ListFunctionsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFunctionsError {}
#[derive(Debug, PartialEq)]
pub enum ListFunctionsByCodeSigningConfigError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
}
impl ListFunctionsByCodeSigningConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListFunctionsByCodeSigningConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ListFunctionsByCodeSigningConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListFunctionsByCodeSigningConfigError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(ListFunctionsByCodeSigningConfigError::Service(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFunctionsByCodeSigningConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFunctionsByCodeSigningConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListFunctionsByCodeSigningConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListFunctionsByCodeSigningConfigError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFunctionsByCodeSigningConfigError {}
#[derive(Debug, PartialEq)]
pub enum ListLayerVersionsError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl ListLayerVersionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLayerVersionsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListLayerVersionsError::InvalidParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListLayerVersionsError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListLayerVersionsError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListLayerVersionsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLayerVersionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLayerVersionsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListLayerVersionsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListLayerVersionsError::Service(ref cause) => write!(f, "{}", cause),
ListLayerVersionsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLayerVersionsError {}
#[derive(Debug, PartialEq)]
pub enum ListLayersError {
InvalidParameterValue(String),
Service(String),
TooManyRequests(String),
}
impl ListLayersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListLayersError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListLayersError::InvalidParameterValue(err.msg))
}
"ServiceException" => {
return RusotoError::Service(ListLayersError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListLayersError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListLayersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListLayersError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListLayersError::Service(ref cause) => write!(f, "{}", cause),
ListLayersError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListLayersError {}
#[derive(Debug, PartialEq)]
pub enum ListProvisionedConcurrencyConfigsError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl ListProvisionedConcurrencyConfigsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListProvisionedConcurrencyConfigsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ListProvisionedConcurrencyConfigsError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListProvisionedConcurrencyConfigsError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(ListProvisionedConcurrencyConfigsError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
ListProvisionedConcurrencyConfigsError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListProvisionedConcurrencyConfigsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListProvisionedConcurrencyConfigsError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
ListProvisionedConcurrencyConfigsError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListProvisionedConcurrencyConfigsError::Service(ref cause) => write!(f, "{}", cause),
ListProvisionedConcurrencyConfigsError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListProvisionedConcurrencyConfigsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl ListTagsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(ListTagsError::InvalidParameterValue(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsError::ResourceNotFound(err.msg))
}
"ServiceException" => return RusotoError::Service(ListTagsError::Service(err.msg)),
"TooManyRequestsException" => {
return RusotoError::Service(ListTagsError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListTagsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListTagsError::Service(ref cause) => write!(f, "{}", cause),
ListTagsError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsError {}
#[derive(Debug, PartialEq)]
pub enum ListVersionsByFunctionError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl ListVersionsByFunctionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListVersionsByFunctionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
ListVersionsByFunctionError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListVersionsByFunctionError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(ListVersionsByFunctionError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(ListVersionsByFunctionError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListVersionsByFunctionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListVersionsByFunctionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
ListVersionsByFunctionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListVersionsByFunctionError::Service(ref cause) => write!(f, "{}", cause),
ListVersionsByFunctionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListVersionsByFunctionError {}
#[derive(Debug, PartialEq)]
pub enum PublishLayerVersionError {
CodeStorageExceeded(String),
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl PublishLayerVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PublishLayerVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CodeStorageExceededException" => {
return RusotoError::Service(PublishLayerVersionError::CodeStorageExceeded(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(PublishLayerVersionError::InvalidParameterValue(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(PublishLayerVersionError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(PublishLayerVersionError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(PublishLayerVersionError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PublishLayerVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PublishLayerVersionError::CodeStorageExceeded(ref cause) => write!(f, "{}", cause),
PublishLayerVersionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PublishLayerVersionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PublishLayerVersionError::Service(ref cause) => write!(f, "{}", cause),
PublishLayerVersionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PublishLayerVersionError {}
#[derive(Debug, PartialEq)]
pub enum PublishVersionError {
CodeStorageExceeded(String),
InvalidParameterValue(String),
PreconditionFailed(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl PublishVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PublishVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CodeStorageExceededException" => {
return RusotoError::Service(PublishVersionError::CodeStorageExceeded(err.msg))
}
"InvalidParameterValueException" => {
return RusotoError::Service(PublishVersionError::InvalidParameterValue(
err.msg,
))
}
"PreconditionFailedException" => {
return RusotoError::Service(PublishVersionError::PreconditionFailed(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(PublishVersionError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(PublishVersionError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(PublishVersionError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(PublishVersionError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PublishVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PublishVersionError::CodeStorageExceeded(ref cause) => write!(f, "{}", cause),
PublishVersionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PublishVersionError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
PublishVersionError::ResourceConflict(ref cause) => write!(f, "{}", cause),
PublishVersionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PublishVersionError::Service(ref cause) => write!(f, "{}", cause),
PublishVersionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PublishVersionError {}
#[derive(Debug, PartialEq)]
pub enum PutFunctionCodeSigningConfigError {
CodeSigningConfigNotFound(String),
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl PutFunctionCodeSigningConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutFunctionCodeSigningConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CodeSigningConfigNotFoundException" => {
return RusotoError::Service(
PutFunctionCodeSigningConfigError::CodeSigningConfigNotFound(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
PutFunctionCodeSigningConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceConflictException" => {
return RusotoError::Service(
PutFunctionCodeSigningConfigError::ResourceConflict(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
PutFunctionCodeSigningConfigError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(PutFunctionCodeSigningConfigError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutFunctionCodeSigningConfigError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutFunctionCodeSigningConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutFunctionCodeSigningConfigError::CodeSigningConfigNotFound(ref cause) => {
write!(f, "{}", cause)
}
PutFunctionCodeSigningConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PutFunctionCodeSigningConfigError::ResourceConflict(ref cause) => {
write!(f, "{}", cause)
}
PutFunctionCodeSigningConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
PutFunctionCodeSigningConfigError::Service(ref cause) => write!(f, "{}", cause),
PutFunctionCodeSigningConfigError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutFunctionCodeSigningConfigError {}
#[derive(Debug, PartialEq)]
pub enum PutFunctionConcurrencyError {
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl PutFunctionConcurrencyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutFunctionConcurrencyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
PutFunctionConcurrencyError::InvalidParameterValue(err.msg),
)
}
"ResourceConflictException" => {
return RusotoError::Service(PutFunctionConcurrencyError::ResourceConflict(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(PutFunctionConcurrencyError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(PutFunctionConcurrencyError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(PutFunctionConcurrencyError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutFunctionConcurrencyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutFunctionConcurrencyError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
PutFunctionConcurrencyError::ResourceConflict(ref cause) => write!(f, "{}", cause),
PutFunctionConcurrencyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PutFunctionConcurrencyError::Service(ref cause) => write!(f, "{}", cause),
PutFunctionConcurrencyError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutFunctionConcurrencyError {}
#[derive(Debug, PartialEq)]
pub enum PutFunctionEventInvokeConfigError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl PutFunctionEventInvokeConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutFunctionEventInvokeConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
PutFunctionEventInvokeConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
PutFunctionEventInvokeConfigError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(PutFunctionEventInvokeConfigError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutFunctionEventInvokeConfigError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutFunctionEventInvokeConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutFunctionEventInvokeConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PutFunctionEventInvokeConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
PutFunctionEventInvokeConfigError::Service(ref cause) => write!(f, "{}", cause),
PutFunctionEventInvokeConfigError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutFunctionEventInvokeConfigError {}
#[derive(Debug, PartialEq)]
pub enum PutProvisionedConcurrencyConfigError {
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl PutProvisionedConcurrencyConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PutProvisionedConcurrencyConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
PutProvisionedConcurrencyConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceConflictException" => {
return RusotoError::Service(
PutProvisionedConcurrencyConfigError::ResourceConflict(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
PutProvisionedConcurrencyConfigError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(PutProvisionedConcurrencyConfigError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
PutProvisionedConcurrencyConfigError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutProvisionedConcurrencyConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutProvisionedConcurrencyConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
PutProvisionedConcurrencyConfigError::ResourceConflict(ref cause) => {
write!(f, "{}", cause)
}
PutProvisionedConcurrencyConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
PutProvisionedConcurrencyConfigError::Service(ref cause) => write!(f, "{}", cause),
PutProvisionedConcurrencyConfigError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutProvisionedConcurrencyConfigError {}
#[derive(Debug, PartialEq)]
pub enum RemoveLayerVersionPermissionError {
InvalidParameterValue(String),
PreconditionFailed(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl RemoveLayerVersionPermissionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<RemoveLayerVersionPermissionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
RemoveLayerVersionPermissionError::InvalidParameterValue(err.msg),
)
}
"PreconditionFailedException" => {
return RusotoError::Service(
RemoveLayerVersionPermissionError::PreconditionFailed(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
RemoveLayerVersionPermissionError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(RemoveLayerVersionPermissionError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
RemoveLayerVersionPermissionError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveLayerVersionPermissionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveLayerVersionPermissionError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
RemoveLayerVersionPermissionError::PreconditionFailed(ref cause) => {
write!(f, "{}", cause)
}
RemoveLayerVersionPermissionError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
RemoveLayerVersionPermissionError::Service(ref cause) => write!(f, "{}", cause),
RemoveLayerVersionPermissionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveLayerVersionPermissionError {}
#[derive(Debug, PartialEq)]
pub enum RemovePermissionError {
InvalidParameterValue(String),
PreconditionFailed(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl RemovePermissionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemovePermissionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(RemovePermissionError::InvalidParameterValue(
err.msg,
))
}
"PreconditionFailedException" => {
return RusotoError::Service(RemovePermissionError::PreconditionFailed(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(RemovePermissionError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(RemovePermissionError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(RemovePermissionError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemovePermissionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemovePermissionError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
RemovePermissionError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
RemovePermissionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
RemovePermissionError::Service(ref cause) => write!(f, "{}", cause),
RemovePermissionError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemovePermissionError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(TagResourceError::InvalidParameterValue(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(TagResourceError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(TagResourceError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(TagResourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceConflict(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::Service(ref cause) => write!(f, "{}", cause),
TagResourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InvalidParameterValue(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(UntagResourceError::InvalidParameterValue(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(UntagResourceError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UntagResourceError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UntagResourceError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceConflict(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::Service(ref cause) => write!(f, "{}", cause),
UntagResourceError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateAliasError {
InvalidParameterValue(String),
PreconditionFailed(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl UpdateAliasError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateAliasError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(UpdateAliasError::InvalidParameterValue(err.msg))
}
"PreconditionFailedException" => {
return RusotoError::Service(UpdateAliasError::PreconditionFailed(err.msg))
}
"ResourceConflictException" => {
return RusotoError::Service(UpdateAliasError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateAliasError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UpdateAliasError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateAliasError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateAliasError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateAliasError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
UpdateAliasError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
UpdateAliasError::ResourceConflict(ref cause) => write!(f, "{}", cause),
UpdateAliasError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateAliasError::Service(ref cause) => write!(f, "{}", cause),
UpdateAliasError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateAliasError {}
#[derive(Debug, PartialEq)]
pub enum UpdateCodeSigningConfigError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
}
impl UpdateCodeSigningConfigError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateCodeSigningConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
UpdateCodeSigningConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateCodeSigningConfigError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(UpdateCodeSigningConfigError::Service(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateCodeSigningConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateCodeSigningConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
UpdateCodeSigningConfigError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateCodeSigningConfigError::Service(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateCodeSigningConfigError {}
#[derive(Debug, PartialEq)]
pub enum UpdateEventSourceMappingError {
InvalidParameterValue(String),
ResourceConflict(String),
ResourceInUse(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl UpdateEventSourceMappingError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateEventSourceMappingError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
UpdateEventSourceMappingError::InvalidParameterValue(err.msg),
)
}
"ResourceConflictException" => {
return RusotoError::Service(UpdateEventSourceMappingError::ResourceConflict(
err.msg,
))
}
"ResourceInUseException" => {
return RusotoError::Service(UpdateEventSourceMappingError::ResourceInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateEventSourceMappingError::ResourceNotFound(
err.msg,
))
}
"ServiceException" => {
return RusotoError::Service(UpdateEventSourceMappingError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateEventSourceMappingError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateEventSourceMappingError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateEventSourceMappingError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
UpdateEventSourceMappingError::ResourceConflict(ref cause) => write!(f, "{}", cause),
UpdateEventSourceMappingError::ResourceInUse(ref cause) => write!(f, "{}", cause),
UpdateEventSourceMappingError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateEventSourceMappingError::Service(ref cause) => write!(f, "{}", cause),
UpdateEventSourceMappingError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateEventSourceMappingError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFunctionCodeError {
CodeSigningConfigNotFound(String),
CodeStorageExceeded(String),
CodeVerificationFailed(String),
InvalidCodeSignature(String),
InvalidParameterValue(String),
PreconditionFailed(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl UpdateFunctionCodeError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFunctionCodeError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CodeSigningConfigNotFoundException" => {
return RusotoError::Service(
UpdateFunctionCodeError::CodeSigningConfigNotFound(err.msg),
)
}
"CodeStorageExceededException" => {
return RusotoError::Service(UpdateFunctionCodeError::CodeStorageExceeded(
err.msg,
))
}
"CodeVerificationFailedException" => {
return RusotoError::Service(UpdateFunctionCodeError::CodeVerificationFailed(
err.msg,
))
}
"InvalidCodeSignatureException" => {
return RusotoError::Service(UpdateFunctionCodeError::InvalidCodeSignature(
err.msg,
))
}
"InvalidParameterValueException" => {
return RusotoError::Service(UpdateFunctionCodeError::InvalidParameterValue(
err.msg,
))
}
"PreconditionFailedException" => {
return RusotoError::Service(UpdateFunctionCodeError::PreconditionFailed(
err.msg,
))
}
"ResourceConflictException" => {
return RusotoError::Service(UpdateFunctionCodeError::ResourceConflict(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateFunctionCodeError::ResourceNotFound(err.msg))
}
"ServiceException" => {
return RusotoError::Service(UpdateFunctionCodeError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateFunctionCodeError::TooManyRequests(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFunctionCodeError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFunctionCodeError::CodeSigningConfigNotFound(ref cause) => write!(f, "{}", cause),
UpdateFunctionCodeError::CodeStorageExceeded(ref cause) => write!(f, "{}", cause),
UpdateFunctionCodeError::CodeVerificationFailed(ref cause) => write!(f, "{}", cause),
UpdateFunctionCodeError::InvalidCodeSignature(ref cause) => write!(f, "{}", cause),
UpdateFunctionCodeError::InvalidParameterValue(ref cause) => write!(f, "{}", cause),
UpdateFunctionCodeError::PreconditionFailed(ref cause) => write!(f, "{}", cause),
UpdateFunctionCodeError::ResourceConflict(ref cause) => write!(f, "{}", cause),
UpdateFunctionCodeError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateFunctionCodeError::Service(ref cause) => write!(f, "{}", cause),
UpdateFunctionCodeError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFunctionCodeError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFunctionConfigurationError {
CodeSigningConfigNotFound(String),
CodeVerificationFailed(String),
InvalidCodeSignature(String),
InvalidParameterValue(String),
PreconditionFailed(String),
ResourceConflict(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl UpdateFunctionConfigurationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateFunctionConfigurationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"CodeSigningConfigNotFoundException" => {
return RusotoError::Service(
UpdateFunctionConfigurationError::CodeSigningConfigNotFound(err.msg),
)
}
"CodeVerificationFailedException" => {
return RusotoError::Service(
UpdateFunctionConfigurationError::CodeVerificationFailed(err.msg),
)
}
"InvalidCodeSignatureException" => {
return RusotoError::Service(
UpdateFunctionConfigurationError::InvalidCodeSignature(err.msg),
)
}
"InvalidParameterValueException" => {
return RusotoError::Service(
UpdateFunctionConfigurationError::InvalidParameterValue(err.msg),
)
}
"PreconditionFailedException" => {
return RusotoError::Service(
UpdateFunctionConfigurationError::PreconditionFailed(err.msg),
)
}
"ResourceConflictException" => {
return RusotoError::Service(
UpdateFunctionConfigurationError::ResourceConflict(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
UpdateFunctionConfigurationError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(UpdateFunctionConfigurationError::Service(err.msg))
}
"TooManyRequestsException" => {
return RusotoError::Service(UpdateFunctionConfigurationError::TooManyRequests(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFunctionConfigurationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFunctionConfigurationError::CodeSigningConfigNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateFunctionConfigurationError::CodeVerificationFailed(ref cause) => {
write!(f, "{}", cause)
}
UpdateFunctionConfigurationError::InvalidCodeSignature(ref cause) => {
write!(f, "{}", cause)
}
UpdateFunctionConfigurationError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
UpdateFunctionConfigurationError::PreconditionFailed(ref cause) => {
write!(f, "{}", cause)
}
UpdateFunctionConfigurationError::ResourceConflict(ref cause) => write!(f, "{}", cause),
UpdateFunctionConfigurationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateFunctionConfigurationError::Service(ref cause) => write!(f, "{}", cause),
UpdateFunctionConfigurationError::TooManyRequests(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFunctionConfigurationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFunctionEventInvokeConfigError {
InvalidParameterValue(String),
ResourceNotFound(String),
Service(String),
TooManyRequests(String),
}
impl UpdateFunctionEventInvokeConfigError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateFunctionEventInvokeConfigError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"InvalidParameterValueException" => {
return RusotoError::Service(
UpdateFunctionEventInvokeConfigError::InvalidParameterValue(err.msg),
)
}
"ResourceNotFoundException" => {
return RusotoError::Service(
UpdateFunctionEventInvokeConfigError::ResourceNotFound(err.msg),
)
}
"ServiceException" => {
return RusotoError::Service(UpdateFunctionEventInvokeConfigError::Service(
err.msg,
))
}
"TooManyRequestsException" => {
return RusotoError::Service(
UpdateFunctionEventInvokeConfigError::TooManyRequests(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFunctionEventInvokeConfigError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFunctionEventInvokeConfigError::InvalidParameterValue(ref cause) => {
write!(f, "{}", cause)
}
UpdateFunctionEventInvokeConfigError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateFunctionEventInvokeConfigError::Service(ref cause) => write!(f, "{}", cause),
UpdateFunctionEventInvokeConfigError::TooManyRequests(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateFunctionEventInvokeConfigError {}
#[async_trait]
pub trait Lambda {
async fn add_layer_version_permission(
&self,
input: AddLayerVersionPermissionRequest,
) -> Result<AddLayerVersionPermissionResponse, RusotoError<AddLayerVersionPermissionError>>;
async fn add_permission(
&self,
input: AddPermissionRequest,
) -> Result<AddPermissionResponse, RusotoError<AddPermissionError>>;
async fn create_alias(
&self,
input: CreateAliasRequest,
) -> Result<AliasConfiguration, RusotoError<CreateAliasError>>;
async fn create_code_signing_config(
&self,
input: CreateCodeSigningConfigRequest,
) -> Result<CreateCodeSigningConfigResponse, RusotoError<CreateCodeSigningConfigError>>;
async fn create_event_source_mapping(
&self,
input: CreateEventSourceMappingRequest,
) -> Result<EventSourceMappingConfiguration, RusotoError<CreateEventSourceMappingError>>;
async fn create_function(
&self,
input: CreateFunctionRequest,
) -> Result<FunctionConfiguration, RusotoError<CreateFunctionError>>;
async fn delete_alias(
&self,
input: DeleteAliasRequest,
) -> Result<(), RusotoError<DeleteAliasError>>;
async fn delete_code_signing_config(
&self,
input: DeleteCodeSigningConfigRequest,
) -> Result<DeleteCodeSigningConfigResponse, RusotoError<DeleteCodeSigningConfigError>>;
async fn delete_event_source_mapping(
&self,
input: DeleteEventSourceMappingRequest,
) -> Result<EventSourceMappingConfiguration, RusotoError<DeleteEventSourceMappingError>>;
async fn delete_function(
&self,
input: DeleteFunctionRequest,
) -> Result<(), RusotoError<DeleteFunctionError>>;
async fn delete_function_code_signing_config(
&self,
input: DeleteFunctionCodeSigningConfigRequest,
) -> Result<(), RusotoError<DeleteFunctionCodeSigningConfigError>>;
async fn delete_function_concurrency(
&self,
input: DeleteFunctionConcurrencyRequest,
) -> Result<(), RusotoError<DeleteFunctionConcurrencyError>>;
async fn delete_function_event_invoke_config(
&self,
input: DeleteFunctionEventInvokeConfigRequest,
) -> Result<(), RusotoError<DeleteFunctionEventInvokeConfigError>>;
async fn delete_layer_version(
&self,
input: DeleteLayerVersionRequest,
) -> Result<(), RusotoError<DeleteLayerVersionError>>;
async fn delete_provisioned_concurrency_config(
&self,
input: DeleteProvisionedConcurrencyConfigRequest,
) -> Result<(), RusotoError<DeleteProvisionedConcurrencyConfigError>>;
async fn get_account_settings(
&self,
) -> Result<GetAccountSettingsResponse, RusotoError<GetAccountSettingsError>>;
async fn get_alias(
&self,
input: GetAliasRequest,
) -> Result<AliasConfiguration, RusotoError<GetAliasError>>;
async fn get_code_signing_config(
&self,
input: GetCodeSigningConfigRequest,
) -> Result<GetCodeSigningConfigResponse, RusotoError<GetCodeSigningConfigError>>;
async fn get_event_source_mapping(
&self,
input: GetEventSourceMappingRequest,
) -> Result<EventSourceMappingConfiguration, RusotoError<GetEventSourceMappingError>>;
async fn get_function(
&self,
input: GetFunctionRequest,
) -> Result<GetFunctionResponse, RusotoError<GetFunctionError>>;
async fn get_function_code_signing_config(
&self,
input: GetFunctionCodeSigningConfigRequest,
) -> Result<GetFunctionCodeSigningConfigResponse, RusotoError<GetFunctionCodeSigningConfigError>>;
async fn get_function_concurrency(
&self,
input: GetFunctionConcurrencyRequest,
) -> Result<GetFunctionConcurrencyResponse, RusotoError<GetFunctionConcurrencyError>>;
async fn get_function_configuration(
&self,
input: GetFunctionConfigurationRequest,
) -> Result<FunctionConfiguration, RusotoError<GetFunctionConfigurationError>>;
async fn get_function_event_invoke_config(
&self,
input: GetFunctionEventInvokeConfigRequest,
) -> Result<FunctionEventInvokeConfig, RusotoError<GetFunctionEventInvokeConfigError>>;
async fn get_layer_version(
&self,
input: GetLayerVersionRequest,
) -> Result<GetLayerVersionResponse, RusotoError<GetLayerVersionError>>;
async fn get_layer_version_by_arn(
&self,
input: GetLayerVersionByArnRequest,
) -> Result<GetLayerVersionResponse, RusotoError<GetLayerVersionByArnError>>;
async fn get_layer_version_policy(
&self,
input: GetLayerVersionPolicyRequest,
) -> Result<GetLayerVersionPolicyResponse, RusotoError<GetLayerVersionPolicyError>>;
async fn get_policy(
&self,
input: GetPolicyRequest,
) -> Result<GetPolicyResponse, RusotoError<GetPolicyError>>;
async fn get_provisioned_concurrency_config(
&self,
input: GetProvisionedConcurrencyConfigRequest,
) -> Result<
GetProvisionedConcurrencyConfigResponse,
RusotoError<GetProvisionedConcurrencyConfigError>,
>;
async fn invoke(
&self,
input: InvocationRequest,
) -> Result<InvocationResponse, RusotoError<InvokeError>>;
async fn invoke_async(
&self,
input: InvokeAsyncRequest,
) -> Result<InvokeAsyncResponse, RusotoError<InvokeAsyncError>>;
async fn list_aliases(
&self,
input: ListAliasesRequest,
) -> Result<ListAliasesResponse, RusotoError<ListAliasesError>>;
async fn list_code_signing_configs(
&self,
input: ListCodeSigningConfigsRequest,
) -> Result<ListCodeSigningConfigsResponse, RusotoError<ListCodeSigningConfigsError>>;
async fn list_event_source_mappings(
&self,
input: ListEventSourceMappingsRequest,
) -> Result<ListEventSourceMappingsResponse, RusotoError<ListEventSourceMappingsError>>;
async fn list_function_event_invoke_configs(
&self,
input: ListFunctionEventInvokeConfigsRequest,
) -> Result<
ListFunctionEventInvokeConfigsResponse,
RusotoError<ListFunctionEventInvokeConfigsError>,
>;
async fn list_functions(
&self,
input: ListFunctionsRequest,
) -> Result<ListFunctionsResponse, RusotoError<ListFunctionsError>>;
async fn list_functions_by_code_signing_config(
&self,
input: ListFunctionsByCodeSigningConfigRequest,
) -> Result<
ListFunctionsByCodeSigningConfigResponse,
RusotoError<ListFunctionsByCodeSigningConfigError>,
>;
async fn list_layer_versions(
&self,
input: ListLayerVersionsRequest,
) -> Result<ListLayerVersionsResponse, RusotoError<ListLayerVersionsError>>;
async fn list_layers(
&self,
input: ListLayersRequest,
) -> Result<ListLayersResponse, RusotoError<ListLayersError>>;
async fn list_provisioned_concurrency_configs(
&self,
input: ListProvisionedConcurrencyConfigsRequest,
) -> Result<
ListProvisionedConcurrencyConfigsResponse,
RusotoError<ListProvisionedConcurrencyConfigsError>,
>;
async fn list_tags(
&self,
input: ListTagsRequest,
) -> Result<ListTagsResponse, RusotoError<ListTagsError>>;
async fn list_versions_by_function(
&self,
input: ListVersionsByFunctionRequest,
) -> Result<ListVersionsByFunctionResponse, RusotoError<ListVersionsByFunctionError>>;
async fn publish_layer_version(
&self,
input: PublishLayerVersionRequest,
) -> Result<PublishLayerVersionResponse, RusotoError<PublishLayerVersionError>>;
async fn publish_version(
&self,
input: PublishVersionRequest,
) -> Result<FunctionConfiguration, RusotoError<PublishVersionError>>;
async fn put_function_code_signing_config(
&self,
input: PutFunctionCodeSigningConfigRequest,
) -> Result<PutFunctionCodeSigningConfigResponse, RusotoError<PutFunctionCodeSigningConfigError>>;
async fn put_function_concurrency(
&self,
input: PutFunctionConcurrencyRequest,
) -> Result<Concurrency, RusotoError<PutFunctionConcurrencyError>>;
async fn put_function_event_invoke_config(
&self,
input: PutFunctionEventInvokeConfigRequest,
) -> Result<FunctionEventInvokeConfig, RusotoError<PutFunctionEventInvokeConfigError>>;
async fn put_provisioned_concurrency_config(
&self,
input: PutProvisionedConcurrencyConfigRequest,
) -> Result<
PutProvisionedConcurrencyConfigResponse,
RusotoError<PutProvisionedConcurrencyConfigError>,
>;
async fn remove_layer_version_permission(
&self,
input: RemoveLayerVersionPermissionRequest,
) -> Result<(), RusotoError<RemoveLayerVersionPermissionError>>;
async fn remove_permission(
&self,
input: RemovePermissionRequest,
) -> Result<(), RusotoError<RemovePermissionError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>>;
async fn update_alias(
&self,
input: UpdateAliasRequest,
) -> Result<AliasConfiguration, RusotoError<UpdateAliasError>>;
async fn update_code_signing_config(
&self,
input: UpdateCodeSigningConfigRequest,
) -> Result<UpdateCodeSigningConfigResponse, RusotoError<UpdateCodeSigningConfigError>>;
async fn update_event_source_mapping(
&self,
input: UpdateEventSourceMappingRequest,
) -> Result<EventSourceMappingConfiguration, RusotoError<UpdateEventSourceMappingError>>;
async fn update_function_code(
&self,
input: UpdateFunctionCodeRequest,
) -> Result<FunctionConfiguration, RusotoError<UpdateFunctionCodeError>>;
async fn update_function_configuration(
&self,
input: UpdateFunctionConfigurationRequest,
) -> Result<FunctionConfiguration, RusotoError<UpdateFunctionConfigurationError>>;
async fn update_function_event_invoke_config(
&self,
input: UpdateFunctionEventInvokeConfigRequest,
) -> Result<FunctionEventInvokeConfig, RusotoError<UpdateFunctionEventInvokeConfigError>>;
}
#[derive(Clone)]
pub struct LambdaClient {
client: Client,
region: region::Region,
}
impl LambdaClient {
pub fn new(region: region::Region) -> LambdaClient {
LambdaClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> LambdaClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
LambdaClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> LambdaClient {
LambdaClient { client, region }
}
}
#[async_trait]
impl Lambda for LambdaClient {
#[allow(unused_mut)]
async fn add_layer_version_permission(
&self,
input: AddLayerVersionPermissionRequest,
) -> Result<AddLayerVersionPermissionResponse, RusotoError<AddLayerVersionPermissionError>>
{
let request_uri = format!(
"/2018-10-31/layers/{layer_name}/versions/{version_number}/policy",
layer_name = input.layer_name,
version_number = input.version_number
);
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut params = Params::new();
if let Some(ref x) = input.revision_id {
params.put("RevisionId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AddLayerVersionPermissionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AddLayerVersionPermissionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn add_permission(
&self,
input: AddPermissionRequest,
) -> Result<AddPermissionResponse, RusotoError<AddPermissionError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/policy",
function_name = input.function_name
);
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut params = Params::new();
if let Some(ref x) = input.qualifier {
params.put("Qualifier", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AddPermissionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AddPermissionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_alias(
&self,
input: CreateAliasRequest,
) -> Result<AliasConfiguration, RusotoError<CreateAliasError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/aliases",
function_name = input.function_name
);
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AliasConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateAliasError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_code_signing_config(
&self,
input: CreateCodeSigningConfigRequest,
) -> Result<CreateCodeSigningConfigResponse, RusotoError<CreateCodeSigningConfigError>> {
let request_uri = "/2020-04-22/code-signing-configs/";
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateCodeSigningConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateCodeSigningConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_event_source_mapping(
&self,
input: CreateEventSourceMappingRequest,
) -> Result<EventSourceMappingConfiguration, RusotoError<CreateEventSourceMappingError>> {
let request_uri = "/2015-03-31/event-source-mappings/";
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<EventSourceMappingConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateEventSourceMappingError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_function(
&self,
input: CreateFunctionRequest,
) -> Result<FunctionConfiguration, RusotoError<CreateFunctionError>> {
let request_uri = "/2015-03-31/functions";
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<FunctionConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateFunctionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_alias(
&self,
input: DeleteAliasRequest,
) -> Result<(), RusotoError<DeleteAliasError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/aliases/{name}",
function_name = input.function_name,
name = input.name
);
let mut request = SignedRequest::new("DELETE", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteAliasError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_code_signing_config(
&self,
input: DeleteCodeSigningConfigRequest,
) -> Result<DeleteCodeSigningConfigResponse, RusotoError<DeleteCodeSigningConfigError>> {
let request_uri = format!(
"/2020-04-22/code-signing-configs/{code_signing_config_arn}",
code_signing_config_arn = input.code_signing_config_arn
);
let mut request = SignedRequest::new("DELETE", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteCodeSigningConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteCodeSigningConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_event_source_mapping(
&self,
input: DeleteEventSourceMappingRequest,
) -> Result<EventSourceMappingConfiguration, RusotoError<DeleteEventSourceMappingError>> {
let request_uri = format!(
"/2015-03-31/event-source-mappings/{uuid}",
uuid = input.uuid
);
let mut request = SignedRequest::new("DELETE", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<EventSourceMappingConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteEventSourceMappingError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_function(
&self,
input: DeleteFunctionRequest,
) -> Result<(), RusotoError<DeleteFunctionError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}",
function_name = input.function_name
);
let mut request = SignedRequest::new("DELETE", "lambda", &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.qualifier {
params.put("Qualifier", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFunctionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_function_code_signing_config(
&self,
input: DeleteFunctionCodeSigningConfigRequest,
) -> Result<(), RusotoError<DeleteFunctionCodeSigningConfigError>> {
let request_uri = format!(
"/2020-06-30/functions/{function_name}/code-signing-config",
function_name = input.function_name
);
let mut request = SignedRequest::new("DELETE", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFunctionCodeSigningConfigError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn delete_function_concurrency(
&self,
input: DeleteFunctionConcurrencyRequest,
) -> Result<(), RusotoError<DeleteFunctionConcurrencyError>> {
let request_uri = format!(
"/2017-10-31/functions/{function_name}/concurrency",
function_name = input.function_name
);
let mut request = SignedRequest::new("DELETE", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFunctionConcurrencyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_function_event_invoke_config(
&self,
input: DeleteFunctionEventInvokeConfigRequest,
) -> Result<(), RusotoError<DeleteFunctionEventInvokeConfigError>> {
let request_uri = format!(
"/2019-09-25/functions/{function_name}/event-invoke-config",
function_name = input.function_name
);
let mut request = SignedRequest::new("DELETE", "lambda", &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.qualifier {
params.put("Qualifier", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFunctionEventInvokeConfigError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn delete_layer_version(
&self,
input: DeleteLayerVersionRequest,
) -> Result<(), RusotoError<DeleteLayerVersionError>> {
let request_uri = format!(
"/2018-10-31/layers/{layer_name}/versions/{version_number}",
layer_name = input.layer_name,
version_number = input.version_number
);
let mut request = SignedRequest::new("DELETE", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteLayerVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_provisioned_concurrency_config(
&self,
input: DeleteProvisionedConcurrencyConfigRequest,
) -> Result<(), RusotoError<DeleteProvisionedConcurrencyConfigError>> {
let request_uri = format!(
"/2019-09-30/functions/{function_name}/provisioned-concurrency",
function_name = input.function_name
);
let mut request = SignedRequest::new("DELETE", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("Qualifier", &input.qualifier);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteProvisionedConcurrencyConfigError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn get_account_settings(
&self,
) -> Result<GetAccountSettingsResponse, RusotoError<GetAccountSettingsError>> {
let request_uri = "/2016-08-19/account-settings/";
let mut request = SignedRequest::new("GET", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetAccountSettingsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetAccountSettingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_alias(
&self,
input: GetAliasRequest,
) -> Result<AliasConfiguration, RusotoError<GetAliasError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/aliases/{name}",
function_name = input.function_name,
name = input.name
);
let mut request = SignedRequest::new("GET", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AliasConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetAliasError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_code_signing_config(
&self,
input: GetCodeSigningConfigRequest,
) -> Result<GetCodeSigningConfigResponse, RusotoError<GetCodeSigningConfigError>> {
let request_uri = format!(
"/2020-04-22/code-signing-configs/{code_signing_config_arn}",
code_signing_config_arn = input.code_signing_config_arn
);
let mut request = SignedRequest::new("GET", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetCodeSigningConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetCodeSigningConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_event_source_mapping(
&self,
input: GetEventSourceMappingRequest,
) -> Result<EventSourceMappingConfiguration, RusotoError<GetEventSourceMappingError>> {
let request_uri = format!(
"/2015-03-31/event-source-mappings/{uuid}",
uuid = input.uuid
);
let mut request = SignedRequest::new("GET", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<EventSourceMappingConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetEventSourceMappingError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_function(
&self,
input: GetFunctionRequest,
) -> Result<GetFunctionResponse, RusotoError<GetFunctionError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}",
function_name = input.function_name
);
let mut request = SignedRequest::new("GET", "lambda", &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.qualifier {
params.put("Qualifier", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetFunctionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFunctionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_function_code_signing_config(
&self,
input: GetFunctionCodeSigningConfigRequest,
) -> Result<GetFunctionCodeSigningConfigResponse, RusotoError<GetFunctionCodeSigningConfigError>>
{
let request_uri = format!(
"/2020-06-30/functions/{function_name}/code-signing-config",
function_name = input.function_name
);
let mut request = SignedRequest::new("GET", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetFunctionCodeSigningConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFunctionCodeSigningConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_function_concurrency(
&self,
input: GetFunctionConcurrencyRequest,
) -> Result<GetFunctionConcurrencyResponse, RusotoError<GetFunctionConcurrencyError>> {
let request_uri = format!(
"/2019-09-30/functions/{function_name}/concurrency",
function_name = input.function_name
);
let mut request = SignedRequest::new("GET", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetFunctionConcurrencyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFunctionConcurrencyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_function_configuration(
&self,
input: GetFunctionConfigurationRequest,
) -> Result<FunctionConfiguration, RusotoError<GetFunctionConfigurationError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/configuration",
function_name = input.function_name
);
let mut request = SignedRequest::new("GET", "lambda", &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.qualifier {
params.put("Qualifier", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<FunctionConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFunctionConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_function_event_invoke_config(
&self,
input: GetFunctionEventInvokeConfigRequest,
) -> Result<FunctionEventInvokeConfig, RusotoError<GetFunctionEventInvokeConfigError>> {
let request_uri = format!(
"/2019-09-25/functions/{function_name}/event-invoke-config",
function_name = input.function_name
);
let mut request = SignedRequest::new("GET", "lambda", &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.qualifier {
params.put("Qualifier", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<FunctionEventInvokeConfig, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFunctionEventInvokeConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_layer_version(
&self,
input: GetLayerVersionRequest,
) -> Result<GetLayerVersionResponse, RusotoError<GetLayerVersionError>> {
let request_uri = format!(
"/2018-10-31/layers/{layer_name}/versions/{version_number}",
layer_name = input.layer_name,
version_number = input.version_number
);
let mut request = SignedRequest::new("GET", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetLayerVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetLayerVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_layer_version_by_arn(
&self,
input: GetLayerVersionByArnRequest,
) -> Result<GetLayerVersionResponse, RusotoError<GetLayerVersionByArnError>> {
let request_uri = "/2018-10-31/layers";
let mut request = SignedRequest::new("GET", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("Arn", &input.arn);
params.put("find", "LayerVersion");
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetLayerVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetLayerVersionByArnError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_layer_version_policy(
&self,
input: GetLayerVersionPolicyRequest,
) -> Result<GetLayerVersionPolicyResponse, RusotoError<GetLayerVersionPolicyError>> {
let request_uri = format!(
"/2018-10-31/layers/{layer_name}/versions/{version_number}/policy",
layer_name = input.layer_name,
version_number = input.version_number
);
let mut request = SignedRequest::new("GET", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetLayerVersionPolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetLayerVersionPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_policy(
&self,
input: GetPolicyRequest,
) -> Result<GetPolicyResponse, RusotoError<GetPolicyError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/policy",
function_name = input.function_name
);
let mut request = SignedRequest::new("GET", "lambda", &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.qualifier {
params.put("Qualifier", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetPolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_provisioned_concurrency_config(
&self,
input: GetProvisionedConcurrencyConfigRequest,
) -> Result<
GetProvisionedConcurrencyConfigResponse,
RusotoError<GetProvisionedConcurrencyConfigError>,
> {
let request_uri = format!(
"/2019-09-30/functions/{function_name}/provisioned-concurrency",
function_name = input.function_name
);
let mut request = SignedRequest::new("GET", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
params.put("Qualifier", &input.qualifier);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetProvisionedConcurrencyConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetProvisionedConcurrencyConfigError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn invoke(
&self,
input: InvocationRequest,
) -> Result<InvocationResponse, RusotoError<InvokeError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/invocations",
function_name = input.function_name
);
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = if let Some(ref payload) = input.payload {
Some(payload.to_owned())
} else {
None
};
request.set_payload(encoded);
request.add_optional_header("X-Amz-Client-Context", input.client_context.as_ref());
request.add_optional_header("X-Amz-Invocation-Type", input.invocation_type.as_ref());
request.add_optional_header("X-Amz-Log-Type", input.log_type.as_ref());
let mut params = Params::new();
if let Some(ref x) = input.qualifier {
params.put("Qualifier", 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 = InvocationResponse::default();
result.payload = Some(response.body);
result.executed_version = response.headers.remove("X-Amz-Executed-Version");
result.function_error = response.headers.remove("X-Amz-Function-Error");
result.log_result = response.headers.remove("X-Amz-Log-Result");
result.status_code = Some(response.status.as_u16() as i64);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(InvokeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn invoke_async(
&self,
input: InvokeAsyncRequest,
) -> Result<InvokeAsyncResponse, RusotoError<InvokeAsyncError>> {
let request_uri = format!(
"/2014-11-13/functions/{function_name}/invoke-async/",
function_name = input.function_name
);
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(input.invoke_args.to_owned());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let mut result = proto::json::ResponsePayload::new(&response)
.deserialize::<InvokeAsyncResponse, _>()?;
result.status = Some(response.status.as_u16() as i64);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(InvokeAsyncError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_aliases(
&self,
input: ListAliasesRequest,
) -> Result<ListAliasesResponse, RusotoError<ListAliasesError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/aliases",
function_name = input.function_name
);
let mut request = SignedRequest::new("GET", "lambda", &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.function_version {
params.put("FunctionVersion", x);
}
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListAliasesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListAliasesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_code_signing_configs(
&self,
input: ListCodeSigningConfigsRequest,
) -> Result<ListCodeSigningConfigsResponse, RusotoError<ListCodeSigningConfigsError>> {
let request_uri = "/2020-04-22/code-signing-configs/";
let mut request = SignedRequest::new("GET", "lambda", &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.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListCodeSigningConfigsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListCodeSigningConfigsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_event_source_mappings(
&self,
input: ListEventSourceMappingsRequest,
) -> Result<ListEventSourceMappingsResponse, RusotoError<ListEventSourceMappingsError>> {
let request_uri = "/2015-03-31/event-source-mappings/";
let mut request = SignedRequest::new("GET", "lambda", &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.event_source_arn {
params.put("EventSourceArn", x);
}
if let Some(ref x) = input.function_name {
params.put("FunctionName", x);
}
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListEventSourceMappingsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListEventSourceMappingsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_function_event_invoke_configs(
&self,
input: ListFunctionEventInvokeConfigsRequest,
) -> Result<
ListFunctionEventInvokeConfigsResponse,
RusotoError<ListFunctionEventInvokeConfigsError>,
> {
let request_uri = format!(
"/2019-09-25/functions/{function_name}/event-invoke-config/list",
function_name = input.function_name
);
let mut request = SignedRequest::new("GET", "lambda", &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.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFunctionEventInvokeConfigsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFunctionEventInvokeConfigsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_functions(
&self,
input: ListFunctionsRequest,
) -> Result<ListFunctionsResponse, RusotoError<ListFunctionsError>> {
let request_uri = "/2015-03-31/functions/";
let mut request = SignedRequest::new("GET", "lambda", &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.function_version {
params.put("FunctionVersion", x);
}
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.master_region {
params.put("MasterRegion", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFunctionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFunctionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_functions_by_code_signing_config(
&self,
input: ListFunctionsByCodeSigningConfigRequest,
) -> Result<
ListFunctionsByCodeSigningConfigResponse,
RusotoError<ListFunctionsByCodeSigningConfigError>,
> {
let request_uri = format!(
"/2020-04-22/code-signing-configs/{code_signing_config_arn}/functions",
code_signing_config_arn = input.code_signing_config_arn
);
let mut request = SignedRequest::new("GET", "lambda", &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.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFunctionsByCodeSigningConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFunctionsByCodeSigningConfigError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_layer_versions(
&self,
input: ListLayerVersionsRequest,
) -> Result<ListLayerVersionsResponse, RusotoError<ListLayerVersionsError>> {
let request_uri = format!(
"/2018-10-31/layers/{layer_name}/versions",
layer_name = input.layer_name
);
let mut request = SignedRequest::new("GET", "lambda", &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.compatible_runtime {
params.put("CompatibleRuntime", x);
}
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListLayerVersionsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListLayerVersionsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_layers(
&self,
input: ListLayersRequest,
) -> Result<ListLayersResponse, RusotoError<ListLayersError>> {
let request_uri = "/2018-10-31/layers";
let mut request = SignedRequest::new("GET", "lambda", &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.compatible_runtime {
params.put("CompatibleRuntime", x);
}
if let Some(ref x) = input.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListLayersResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListLayersError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_provisioned_concurrency_configs(
&self,
input: ListProvisionedConcurrencyConfigsRequest,
) -> Result<
ListProvisionedConcurrencyConfigsResponse,
RusotoError<ListProvisionedConcurrencyConfigsError>,
> {
let request_uri = format!(
"/2019-09-30/functions/{function_name}/provisioned-concurrency",
function_name = input.function_name
);
let mut request = SignedRequest::new("GET", "lambda", &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.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
params.put("List", "ALL");
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListProvisionedConcurrencyConfigsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListProvisionedConcurrencyConfigsError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn list_tags(
&self,
input: ListTagsRequest,
) -> Result<ListTagsResponse, RusotoError<ListTagsError>> {
let request_uri = format!("/2017-03-31/tags/{arn}", arn = input.resource);
let mut request = SignedRequest::new("GET", "lambda", &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::<ListTagsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_versions_by_function(
&self,
input: ListVersionsByFunctionRequest,
) -> Result<ListVersionsByFunctionResponse, RusotoError<ListVersionsByFunctionError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/versions",
function_name = input.function_name
);
let mut request = SignedRequest::new("GET", "lambda", &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.marker {
params.put("Marker", x);
}
if let Some(ref x) = input.max_items {
params.put("MaxItems", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListVersionsByFunctionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListVersionsByFunctionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn publish_layer_version(
&self,
input: PublishLayerVersionRequest,
) -> Result<PublishLayerVersionResponse, RusotoError<PublishLayerVersionError>> {
let request_uri = format!(
"/2018-10-31/layers/{layer_name}/versions",
layer_name = input.layer_name
);
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PublishLayerVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PublishLayerVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn publish_version(
&self,
input: PublishVersionRequest,
) -> Result<FunctionConfiguration, RusotoError<PublishVersionError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/versions",
function_name = input.function_name
);
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 201 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<FunctionConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PublishVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_function_code_signing_config(
&self,
input: PutFunctionCodeSigningConfigRequest,
) -> Result<PutFunctionCodeSigningConfigResponse, RusotoError<PutFunctionCodeSigningConfigError>>
{
let request_uri = format!(
"/2020-06-30/functions/{function_name}/code-signing-config",
function_name = input.function_name
);
let mut request = SignedRequest::new("PUT", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutFunctionCodeSigningConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutFunctionCodeSigningConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_function_concurrency(
&self,
input: PutFunctionConcurrencyRequest,
) -> Result<Concurrency, RusotoError<PutFunctionConcurrencyError>> {
let request_uri = format!(
"/2017-10-31/functions/{function_name}/concurrency",
function_name = input.function_name
);
let mut request = SignedRequest::new("PUT", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<Concurrency, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutFunctionConcurrencyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_function_event_invoke_config(
&self,
input: PutFunctionEventInvokeConfigRequest,
) -> Result<FunctionEventInvokeConfig, RusotoError<PutFunctionEventInvokeConfigError>> {
let request_uri = format!(
"/2019-09-25/functions/{function_name}/event-invoke-config",
function_name = input.function_name
);
let mut request = SignedRequest::new("PUT", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut params = Params::new();
if let Some(ref x) = input.qualifier {
params.put("Qualifier", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<FunctionEventInvokeConfig, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutFunctionEventInvokeConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_provisioned_concurrency_config(
&self,
input: PutProvisionedConcurrencyConfigRequest,
) -> Result<
PutProvisionedConcurrencyConfigResponse,
RusotoError<PutProvisionedConcurrencyConfigError>,
> {
let request_uri = format!(
"/2019-09-30/functions/{function_name}/provisioned-concurrency",
function_name = input.function_name
);
let mut request = SignedRequest::new("PUT", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut params = Params::new();
params.put("Qualifier", &input.qualifier);
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutProvisionedConcurrencyConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutProvisionedConcurrencyConfigError::from_response(
response,
))
}
}
#[allow(unused_mut)]
async fn remove_layer_version_permission(
&self,
input: RemoveLayerVersionPermissionRequest,
) -> Result<(), RusotoError<RemoveLayerVersionPermissionError>> {
let request_uri = format!(
"/2018-10-31/layers/{layer_name}/versions/{version_number}/policy/{statement_id}",
layer_name = input.layer_name,
statement_id = input.statement_id,
version_number = input.version_number
);
let mut request = SignedRequest::new("DELETE", "lambda", &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.revision_id {
params.put("RevisionId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RemoveLayerVersionPermissionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn remove_permission(
&self,
input: RemovePermissionRequest,
) -> Result<(), RusotoError<RemovePermissionError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/policy/{statement_id}",
function_name = input.function_name,
statement_id = input.statement_id
);
let mut request = SignedRequest::new("DELETE", "lambda", &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.qualifier {
params.put("Qualifier", x);
}
if let Some(ref x) = input.revision_id {
params.put("RevisionId", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RemovePermissionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<(), RusotoError<TagResourceError>> {
let request_uri = format!("/2017-03-31/tags/{arn}", arn = input.resource);
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<(), RusotoError<UntagResourceError>> {
let request_uri = format!("/2017-03-31/tags/{arn}", arn = input.resource);
let mut request = SignedRequest::new("DELETE", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 204 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_alias(
&self,
input: UpdateAliasRequest,
) -> Result<AliasConfiguration, RusotoError<UpdateAliasError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/aliases/{name}",
function_name = input.function_name,
name = input.name
);
let mut request = SignedRequest::new("PUT", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AliasConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateAliasError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_code_signing_config(
&self,
input: UpdateCodeSigningConfigRequest,
) -> Result<UpdateCodeSigningConfigResponse, RusotoError<UpdateCodeSigningConfigError>> {
let request_uri = format!(
"/2020-04-22/code-signing-configs/{code_signing_config_arn}",
code_signing_config_arn = input.code_signing_config_arn
);
let mut request = SignedRequest::new("PUT", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateCodeSigningConfigResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateCodeSigningConfigError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_event_source_mapping(
&self,
input: UpdateEventSourceMappingRequest,
) -> Result<EventSourceMappingConfiguration, RusotoError<UpdateEventSourceMappingError>> {
let request_uri = format!(
"/2015-03-31/event-source-mappings/{uuid}",
uuid = input.uuid
);
let mut request = SignedRequest::new("PUT", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 202 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<EventSourceMappingConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateEventSourceMappingError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_function_code(
&self,
input: UpdateFunctionCodeRequest,
) -> Result<FunctionConfiguration, RusotoError<UpdateFunctionCodeError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/code",
function_name = input.function_name
);
let mut request = SignedRequest::new("PUT", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<FunctionConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFunctionCodeError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_function_configuration(
&self,
input: UpdateFunctionConfigurationRequest,
) -> Result<FunctionConfiguration, RusotoError<UpdateFunctionConfigurationError>> {
let request_uri = format!(
"/2015-03-31/functions/{function_name}/configuration",
function_name = input.function_name
);
let mut request = SignedRequest::new("PUT", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<FunctionConfiguration, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFunctionConfigurationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_function_event_invoke_config(
&self,
input: UpdateFunctionEventInvokeConfigRequest,
) -> Result<FunctionEventInvokeConfig, RusotoError<UpdateFunctionEventInvokeConfigError>> {
let request_uri = format!(
"/2019-09-25/functions/{function_name}/event-invoke-config",
function_name = input.function_name
);
let mut request = SignedRequest::new("POST", "lambda", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut params = Params::new();
if let Some(ref x) = input.qualifier {
params.put("Qualifier", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<FunctionEventInvokeConfig, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFunctionEventInvokeConfigError::from_response(
response,
))
}
}
}