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 App {
#[serde(rename = "appArn")]
pub app_arn: String,
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "autoBranchCreationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_branch_creation_config: Option<AutoBranchCreationConfig>,
#[serde(rename = "autoBranchCreationPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_branch_creation_patterns: Option<Vec<String>>,
#[serde(rename = "basicAuthCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub basic_auth_credentials: Option<String>,
#[serde(rename = "buildSpec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub build_spec: Option<String>,
#[serde(rename = "createTime")]
pub create_time: f64,
#[serde(rename = "customRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_rules: Option<Vec<CustomRule>>,
#[serde(rename = "defaultDomain")]
pub default_domain: String,
#[serde(rename = "description")]
pub description: String,
#[serde(rename = "enableAutoBranchCreation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_auto_branch_creation: Option<bool>,
#[serde(rename = "enableBasicAuth")]
pub enable_basic_auth: bool,
#[serde(rename = "enableBranchAutoBuild")]
pub enable_branch_auto_build: bool,
#[serde(rename = "enableBranchAutoDeletion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_branch_auto_deletion: Option<bool>,
#[serde(rename = "environmentVariables")]
pub environment_variables: ::std::collections::HashMap<String, String>,
#[serde(rename = "iamServiceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_service_role_arn: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "platform")]
pub platform: String,
#[serde(rename = "productionBranch")]
#[serde(skip_serializing_if = "Option::is_none")]
pub production_branch: Option<ProductionBranch>,
#[serde(rename = "repository")]
pub repository: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "updateTime")]
pub update_time: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Artifact {
#[serde(rename = "artifactFileName")]
pub artifact_file_name: String,
#[serde(rename = "artifactId")]
pub artifact_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AutoBranchCreationConfig {
#[serde(rename = "basicAuthCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub basic_auth_credentials: Option<String>,
#[serde(rename = "buildSpec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub build_spec: Option<String>,
#[serde(rename = "enableAutoBuild")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_auto_build: Option<bool>,
#[serde(rename = "enableBasicAuth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_basic_auth: Option<bool>,
#[serde(rename = "enablePullRequestPreview")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_pull_request_preview: Option<bool>,
#[serde(rename = "environmentVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "framework")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework: Option<String>,
#[serde(rename = "pullRequestEnvironmentName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_environment_name: Option<String>,
#[serde(rename = "stage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BackendEnvironment {
#[serde(rename = "backendEnvironmentArn")]
pub backend_environment_arn: String,
#[serde(rename = "createTime")]
pub create_time: f64,
#[serde(rename = "deploymentArtifacts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_artifacts: Option<String>,
#[serde(rename = "environmentName")]
pub environment_name: String,
#[serde(rename = "stackName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_name: Option<String>,
#[serde(rename = "updateTime")]
pub update_time: f64,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Branch {
#[serde(rename = "activeJobId")]
pub active_job_id: String,
#[serde(rename = "associatedResources")]
#[serde(skip_serializing_if = "Option::is_none")]
pub associated_resources: Option<Vec<String>>,
#[serde(rename = "backendEnvironmentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backend_environment_arn: Option<String>,
#[serde(rename = "basicAuthCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub basic_auth_credentials: Option<String>,
#[serde(rename = "branchArn")]
pub branch_arn: String,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "buildSpec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub build_spec: Option<String>,
#[serde(rename = "createTime")]
pub create_time: f64,
#[serde(rename = "customDomains")]
pub custom_domains: Vec<String>,
#[serde(rename = "description")]
pub description: String,
#[serde(rename = "destinationBranch")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_branch: Option<String>,
#[serde(rename = "displayName")]
pub display_name: String,
#[serde(rename = "enableAutoBuild")]
pub enable_auto_build: bool,
#[serde(rename = "enableBasicAuth")]
pub enable_basic_auth: bool,
#[serde(rename = "enableNotification")]
pub enable_notification: bool,
#[serde(rename = "enablePullRequestPreview")]
pub enable_pull_request_preview: bool,
#[serde(rename = "environmentVariables")]
pub environment_variables: ::std::collections::HashMap<String, String>,
#[serde(rename = "framework")]
pub framework: String,
#[serde(rename = "pullRequestEnvironmentName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_environment_name: Option<String>,
#[serde(rename = "sourceBranch")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_branch: Option<String>,
#[serde(rename = "stage")]
pub stage: String,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "thumbnailUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub thumbnail_url: Option<String>,
#[serde(rename = "totalNumberOfJobs")]
pub total_number_of_jobs: String,
#[serde(rename = "ttl")]
pub ttl: String,
#[serde(rename = "updateTime")]
pub update_time: f64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateAppRequest {
#[serde(rename = "accessToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token: Option<String>,
#[serde(rename = "autoBranchCreationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_branch_creation_config: Option<AutoBranchCreationConfig>,
#[serde(rename = "autoBranchCreationPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_branch_creation_patterns: Option<Vec<String>>,
#[serde(rename = "basicAuthCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub basic_auth_credentials: Option<String>,
#[serde(rename = "buildSpec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub build_spec: Option<String>,
#[serde(rename = "customRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_rules: Option<Vec<CustomRule>>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "enableAutoBranchCreation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_auto_branch_creation: Option<bool>,
#[serde(rename = "enableBasicAuth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_basic_auth: Option<bool>,
#[serde(rename = "enableBranchAutoBuild")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_branch_auto_build: Option<bool>,
#[serde(rename = "enableBranchAutoDeletion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_branch_auto_deletion: Option<bool>,
#[serde(rename = "environmentVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "iamServiceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_service_role_arn: Option<String>,
#[serde(rename = "name")]
pub name: String,
#[serde(rename = "oauthToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub oauth_token: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "repository")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateAppResult {
#[serde(rename = "app")]
pub app: App,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateBackendEnvironmentRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "deploymentArtifacts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deployment_artifacts: Option<String>,
#[serde(rename = "environmentName")]
pub environment_name: String,
#[serde(rename = "stackName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stack_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateBackendEnvironmentResult {
#[serde(rename = "backendEnvironment")]
pub backend_environment: BackendEnvironment,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateBranchRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "backendEnvironmentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backend_environment_arn: Option<String>,
#[serde(rename = "basicAuthCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub basic_auth_credentials: Option<String>,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "buildSpec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub build_spec: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "displayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "enableAutoBuild")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_auto_build: Option<bool>,
#[serde(rename = "enableBasicAuth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_basic_auth: Option<bool>,
#[serde(rename = "enableNotification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_notification: Option<bool>,
#[serde(rename = "enablePullRequestPreview")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_pull_request_preview: Option<bool>,
#[serde(rename = "environmentVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "framework")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework: Option<String>,
#[serde(rename = "pullRequestEnvironmentName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_environment_name: Option<String>,
#[serde(rename = "stage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage: Option<String>,
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "ttl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ttl: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateBranchResult {
#[serde(rename = "branch")]
pub branch: Branch,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDeploymentRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "fileMap")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_map: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDeploymentResult {
#[serde(rename = "fileUploadUrls")]
pub file_upload_urls: ::std::collections::HashMap<String, String>,
#[serde(rename = "jobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
#[serde(rename = "zipUploadUrl")]
pub zip_upload_url: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDomainAssociationRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "autoSubDomainCreationPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_sub_domain_creation_patterns: Option<Vec<String>>,
#[serde(rename = "autoSubDomainIAMRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_sub_domain_iam_role: Option<String>,
#[serde(rename = "domainName")]
pub domain_name: String,
#[serde(rename = "enableAutoSubDomain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_auto_sub_domain: Option<bool>,
#[serde(rename = "subDomainSettings")]
pub sub_domain_settings: Vec<SubDomainSetting>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDomainAssociationResult {
#[serde(rename = "domainAssociation")]
pub domain_association: DomainAssociation,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateWebhookRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateWebhookResult {
#[serde(rename = "webhook")]
pub webhook: Webhook,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct CustomRule {
#[serde(rename = "condition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub condition: Option<String>,
#[serde(rename = "source")]
pub source: String,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "target")]
pub target: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteAppRequest {
#[serde(rename = "appId")]
pub app_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteAppResult {
#[serde(rename = "app")]
pub app: App,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteBackendEnvironmentRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "environmentName")]
pub environment_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteBackendEnvironmentResult {
#[serde(rename = "backendEnvironment")]
pub backend_environment: BackendEnvironment,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteBranchRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "branchName")]
pub branch_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteBranchResult {
#[serde(rename = "branch")]
pub branch: Branch,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDomainAssociationRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "domainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDomainAssociationResult {
#[serde(rename = "domainAssociation")]
pub domain_association: DomainAssociation,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteJobRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "jobId")]
pub job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteJobResult {
#[serde(rename = "jobSummary")]
pub job_summary: JobSummary,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteWebhookRequest {
#[serde(rename = "webhookId")]
pub webhook_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteWebhookResult {
#[serde(rename = "webhook")]
pub webhook: Webhook,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DomainAssociation {
#[serde(rename = "autoSubDomainCreationPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_sub_domain_creation_patterns: Option<Vec<String>>,
#[serde(rename = "autoSubDomainIAMRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_sub_domain_iam_role: Option<String>,
#[serde(rename = "certificateVerificationDNSRecord")]
#[serde(skip_serializing_if = "Option::is_none")]
pub certificate_verification_dns_record: Option<String>,
#[serde(rename = "domainAssociationArn")]
pub domain_association_arn: String,
#[serde(rename = "domainName")]
pub domain_name: String,
#[serde(rename = "domainStatus")]
pub domain_status: String,
#[serde(rename = "enableAutoSubDomain")]
pub enable_auto_sub_domain: bool,
#[serde(rename = "statusReason")]
pub status_reason: String,
#[serde(rename = "subDomains")]
pub sub_domains: Vec<SubDomain>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GenerateAccessLogsRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "domainName")]
pub domain_name: String,
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "startTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_time: Option<f64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GenerateAccessLogsResult {
#[serde(rename = "logUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_url: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAppRequest {
#[serde(rename = "appId")]
pub app_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAppResult {
#[serde(rename = "app")]
pub app: App,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetArtifactUrlRequest {
#[serde(rename = "artifactId")]
pub artifact_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetArtifactUrlResult {
#[serde(rename = "artifactId")]
pub artifact_id: String,
#[serde(rename = "artifactUrl")]
pub artifact_url: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBackendEnvironmentRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "environmentName")]
pub environment_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBackendEnvironmentResult {
#[serde(rename = "backendEnvironment")]
pub backend_environment: BackendEnvironment,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBranchRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "branchName")]
pub branch_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBranchResult {
#[serde(rename = "branch")]
pub branch: Branch,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDomainAssociationRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "domainName")]
pub domain_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDomainAssociationResult {
#[serde(rename = "domainAssociation")]
pub domain_association: DomainAssociation,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetJobRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "jobId")]
pub job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetJobResult {
#[serde(rename = "job")]
pub job: Job,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetWebhookRequest {
#[serde(rename = "webhookId")]
pub webhook_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetWebhookResult {
#[serde(rename = "webhook")]
pub webhook: Webhook,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Job {
#[serde(rename = "steps")]
pub steps: Vec<Step>,
#[serde(rename = "summary")]
pub summary: JobSummary,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct JobSummary {
#[serde(rename = "commitId")]
pub commit_id: String,
#[serde(rename = "commitMessage")]
pub commit_message: String,
#[serde(rename = "commitTime")]
pub commit_time: f64,
#[serde(rename = "endTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_time: Option<f64>,
#[serde(rename = "jobArn")]
pub job_arn: String,
#[serde(rename = "jobId")]
pub job_id: String,
#[serde(rename = "jobType")]
pub job_type: String,
#[serde(rename = "startTime")]
pub start_time: f64,
#[serde(rename = "status")]
pub status: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAppsRequest {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAppsResult {
#[serde(rename = "apps")]
pub apps: Vec<App>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListArtifactsRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "jobId")]
pub job_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListArtifactsResult {
#[serde(rename = "artifacts")]
pub artifacts: Vec<Artifact>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBackendEnvironmentsRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "environmentName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_name: Option<String>,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBackendEnvironmentsResult {
#[serde(rename = "backendEnvironments")]
pub backend_environments: Vec<BackendEnvironment>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListBranchesRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBranchesResult {
#[serde(rename = "branches")]
pub branches: Vec<Branch>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDomainAssociationsRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDomainAssociationsResult {
#[serde(rename = "domainAssociations")]
pub domain_associations: Vec<DomainAssociation>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListJobsRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListJobsResult {
#[serde(rename = "jobSummaries")]
pub job_summaries: Vec<JobSummary>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "tags")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tags: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListWebhooksRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListWebhooksResult {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "webhooks")]
pub webhooks: Vec<Webhook>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ProductionBranch {
#[serde(rename = "branchName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub branch_name: Option<String>,
#[serde(rename = "lastDeployTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_deploy_time: Option<f64>,
#[serde(rename = "status")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status: Option<String>,
#[serde(rename = "thumbnailUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub thumbnail_url: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartDeploymentRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "jobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
#[serde(rename = "sourceUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_url: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartDeploymentResult {
#[serde(rename = "jobSummary")]
pub job_summary: JobSummary,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StartJobRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "commitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_id: Option<String>,
#[serde(rename = "commitMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_message: Option<String>,
#[serde(rename = "commitTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_time: Option<f64>,
#[serde(rename = "jobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_id: Option<String>,
#[serde(rename = "jobReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub job_reason: Option<String>,
#[serde(rename = "jobType")]
pub job_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StartJobResult {
#[serde(rename = "jobSummary")]
pub job_summary: JobSummary,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Step {
#[serde(rename = "artifactsUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub artifacts_url: Option<String>,
#[serde(rename = "context")]
#[serde(skip_serializing_if = "Option::is_none")]
pub context: Option<String>,
#[serde(rename = "endTime")]
pub end_time: f64,
#[serde(rename = "logUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub log_url: Option<String>,
#[serde(rename = "screenshots")]
#[serde(skip_serializing_if = "Option::is_none")]
pub screenshots: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "startTime")]
pub start_time: f64,
#[serde(rename = "status")]
pub status: String,
#[serde(rename = "statusReason")]
#[serde(skip_serializing_if = "Option::is_none")]
pub status_reason: Option<String>,
#[serde(rename = "stepName")]
pub step_name: String,
#[serde(rename = "testArtifactsUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_artifacts_url: Option<String>,
#[serde(rename = "testConfigUrl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub test_config_url: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct StopJobRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "jobId")]
pub job_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct StopJobResult {
#[serde(rename = "jobSummary")]
pub job_summary: JobSummary,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SubDomain {
#[serde(rename = "dnsRecord")]
pub dns_record: String,
#[serde(rename = "subDomainSetting")]
pub sub_domain_setting: SubDomainSetting,
#[serde(rename = "verified")]
pub verified: bool,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SubDomainSetting {
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "prefix")]
pub prefix: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateAppRequest {
#[serde(rename = "accessToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub access_token: Option<String>,
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "autoBranchCreationConfig")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_branch_creation_config: Option<AutoBranchCreationConfig>,
#[serde(rename = "autoBranchCreationPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_branch_creation_patterns: Option<Vec<String>>,
#[serde(rename = "basicAuthCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub basic_auth_credentials: Option<String>,
#[serde(rename = "buildSpec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub build_spec: Option<String>,
#[serde(rename = "customRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_rules: Option<Vec<CustomRule>>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "enableAutoBranchCreation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_auto_branch_creation: Option<bool>,
#[serde(rename = "enableBasicAuth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_basic_auth: Option<bool>,
#[serde(rename = "enableBranchAutoBuild")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_branch_auto_build: Option<bool>,
#[serde(rename = "enableBranchAutoDeletion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_branch_auto_deletion: Option<bool>,
#[serde(rename = "environmentVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "iamServiceRoleArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub iam_service_role_arn: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "oauthToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub oauth_token: Option<String>,
#[serde(rename = "platform")]
#[serde(skip_serializing_if = "Option::is_none")]
pub platform: Option<String>,
#[serde(rename = "repository")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateAppResult {
#[serde(rename = "app")]
pub app: App,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateBranchRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "backendEnvironmentArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub backend_environment_arn: Option<String>,
#[serde(rename = "basicAuthCredentials")]
#[serde(skip_serializing_if = "Option::is_none")]
pub basic_auth_credentials: Option<String>,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "buildSpec")]
#[serde(skip_serializing_if = "Option::is_none")]
pub build_spec: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "displayName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub display_name: Option<String>,
#[serde(rename = "enableAutoBuild")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_auto_build: Option<bool>,
#[serde(rename = "enableBasicAuth")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_basic_auth: Option<bool>,
#[serde(rename = "enableNotification")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_notification: Option<bool>,
#[serde(rename = "enablePullRequestPreview")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_pull_request_preview: Option<bool>,
#[serde(rename = "environmentVariables")]
#[serde(skip_serializing_if = "Option::is_none")]
pub environment_variables: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "framework")]
#[serde(skip_serializing_if = "Option::is_none")]
pub framework: Option<String>,
#[serde(rename = "pullRequestEnvironmentName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_environment_name: Option<String>,
#[serde(rename = "stage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub stage: Option<String>,
#[serde(rename = "ttl")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ttl: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateBranchResult {
#[serde(rename = "branch")]
pub branch: Branch,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDomainAssociationRequest {
#[serde(rename = "appId")]
pub app_id: String,
#[serde(rename = "autoSubDomainCreationPatterns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_sub_domain_creation_patterns: Option<Vec<String>>,
#[serde(rename = "autoSubDomainIAMRole")]
#[serde(skip_serializing_if = "Option::is_none")]
pub auto_sub_domain_iam_role: Option<String>,
#[serde(rename = "domainName")]
pub domain_name: String,
#[serde(rename = "enableAutoSubDomain")]
#[serde(skip_serializing_if = "Option::is_none")]
pub enable_auto_sub_domain: Option<bool>,
#[serde(rename = "subDomainSettings")]
pub sub_domain_settings: Vec<SubDomainSetting>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateDomainAssociationResult {
#[serde(rename = "domainAssociation")]
pub domain_association: DomainAssociation,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateWebhookRequest {
#[serde(rename = "branchName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub branch_name: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "webhookId")]
pub webhook_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateWebhookResult {
#[serde(rename = "webhook")]
pub webhook: Webhook,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Webhook {
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "createTime")]
pub create_time: f64,
#[serde(rename = "description")]
pub description: String,
#[serde(rename = "updateTime")]
pub update_time: f64,
#[serde(rename = "webhookArn")]
pub webhook_arn: String,
#[serde(rename = "webhookId")]
pub webhook_id: String,
#[serde(rename = "webhookUrl")]
pub webhook_url: String,
}
#[derive(Debug, PartialEq)]
pub enum CreateAppError {
BadRequest(String),
DependentServiceFailure(String),
InternalFailure(String),
LimitExceeded(String),
Unauthorized(String),
}
impl CreateAppError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateAppError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateAppError::BadRequest(err.msg))
}
"DependentServiceFailureException" => {
return RusotoError::Service(CreateAppError::DependentServiceFailure(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(CreateAppError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateAppError::LimitExceeded(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateAppError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateAppError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateAppError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateAppError::DependentServiceFailure(ref cause) => write!(f, "{}", cause),
CreateAppError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateAppError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateAppError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateAppError {}
#[derive(Debug, PartialEq)]
pub enum CreateBackendEnvironmentError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl CreateBackendEnvironmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateBackendEnvironmentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateBackendEnvironmentError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(CreateBackendEnvironmentError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateBackendEnvironmentError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(CreateBackendEnvironmentError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateBackendEnvironmentError::Unauthorized(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateBackendEnvironmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateBackendEnvironmentError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateBackendEnvironmentError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateBackendEnvironmentError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateBackendEnvironmentError::NotFound(ref cause) => write!(f, "{}", cause),
CreateBackendEnvironmentError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateBackendEnvironmentError {}
#[derive(Debug, PartialEq)]
pub enum CreateBranchError {
BadRequest(String),
DependentServiceFailure(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl CreateBranchError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateBranchError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateBranchError::BadRequest(err.msg))
}
"DependentServiceFailureException" => {
return RusotoError::Service(CreateBranchError::DependentServiceFailure(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(CreateBranchError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateBranchError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateBranchError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateBranchError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateBranchError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateBranchError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateBranchError::DependentServiceFailure(ref cause) => write!(f, "{}", cause),
CreateBranchError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateBranchError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateBranchError::NotFound(ref cause) => write!(f, "{}", cause),
CreateBranchError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateBranchError {}
#[derive(Debug, PartialEq)]
pub enum CreateDeploymentError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
Unauthorized(String),
}
impl CreateDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateDeploymentError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(CreateDeploymentError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateDeploymentError::LimitExceeded(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateDeploymentError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDeploymentError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDeploymentError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum CreateDomainAssociationError {
BadRequest(String),
DependentServiceFailure(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl CreateDomainAssociationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDomainAssociationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateDomainAssociationError::BadRequest(err.msg))
}
"DependentServiceFailureException" => {
return RusotoError::Service(
CreateDomainAssociationError::DependentServiceFailure(err.msg),
)
}
"InternalFailureException" => {
return RusotoError::Service(CreateDomainAssociationError::InternalFailure(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(CreateDomainAssociationError::LimitExceeded(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(CreateDomainAssociationError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateDomainAssociationError::Unauthorized(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDomainAssociationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDomainAssociationError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateDomainAssociationError::DependentServiceFailure(ref cause) => {
write!(f, "{}", cause)
}
CreateDomainAssociationError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateDomainAssociationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDomainAssociationError::NotFound(ref cause) => write!(f, "{}", cause),
CreateDomainAssociationError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDomainAssociationError {}
#[derive(Debug, PartialEq)]
pub enum CreateWebhookError {
BadRequest(String),
DependentServiceFailure(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl CreateWebhookError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateWebhookError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(CreateWebhookError::BadRequest(err.msg))
}
"DependentServiceFailureException" => {
return RusotoError::Service(CreateWebhookError::DependentServiceFailure(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(CreateWebhookError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateWebhookError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(CreateWebhookError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(CreateWebhookError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateWebhookError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateWebhookError::BadRequest(ref cause) => write!(f, "{}", cause),
CreateWebhookError::DependentServiceFailure(ref cause) => write!(f, "{}", cause),
CreateWebhookError::InternalFailure(ref cause) => write!(f, "{}", cause),
CreateWebhookError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateWebhookError::NotFound(ref cause) => write!(f, "{}", cause),
CreateWebhookError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateWebhookError {}
#[derive(Debug, PartialEq)]
pub enum DeleteAppError {
BadRequest(String),
DependentServiceFailure(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteAppError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteAppError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteAppError::BadRequest(err.msg))
}
"DependentServiceFailureException" => {
return RusotoError::Service(DeleteAppError::DependentServiceFailure(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteAppError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteAppError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteAppError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteAppError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteAppError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteAppError::DependentServiceFailure(ref cause) => write!(f, "{}", cause),
DeleteAppError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteAppError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteAppError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteAppError {}
#[derive(Debug, PartialEq)]
pub enum DeleteBackendEnvironmentError {
BadRequest(String),
DependentServiceFailure(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteBackendEnvironmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteBackendEnvironmentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteBackendEnvironmentError::BadRequest(err.msg))
}
"DependentServiceFailureException" => {
return RusotoError::Service(
DeleteBackendEnvironmentError::DependentServiceFailure(err.msg),
)
}
"InternalFailureException" => {
return RusotoError::Service(DeleteBackendEnvironmentError::InternalFailure(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteBackendEnvironmentError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteBackendEnvironmentError::Unauthorized(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteBackendEnvironmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteBackendEnvironmentError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteBackendEnvironmentError::DependentServiceFailure(ref cause) => {
write!(f, "{}", cause)
}
DeleteBackendEnvironmentError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteBackendEnvironmentError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteBackendEnvironmentError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteBackendEnvironmentError {}
#[derive(Debug, PartialEq)]
pub enum DeleteBranchError {
BadRequest(String),
DependentServiceFailure(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteBranchError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteBranchError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteBranchError::BadRequest(err.msg))
}
"DependentServiceFailureException" => {
return RusotoError::Service(DeleteBranchError::DependentServiceFailure(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteBranchError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteBranchError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteBranchError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteBranchError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteBranchError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteBranchError::DependentServiceFailure(ref cause) => write!(f, "{}", cause),
DeleteBranchError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteBranchError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteBranchError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteBranchError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDomainAssociationError {
BadRequest(String),
DependentServiceFailure(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteDomainAssociationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDomainAssociationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteDomainAssociationError::BadRequest(err.msg))
}
"DependentServiceFailureException" => {
return RusotoError::Service(
DeleteDomainAssociationError::DependentServiceFailure(err.msg),
)
}
"InternalFailureException" => {
return RusotoError::Service(DeleteDomainAssociationError::InternalFailure(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(DeleteDomainAssociationError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteDomainAssociationError::Unauthorized(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDomainAssociationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDomainAssociationError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteDomainAssociationError::DependentServiceFailure(ref cause) => {
write!(f, "{}", cause)
}
DeleteDomainAssociationError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteDomainAssociationError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteDomainAssociationError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDomainAssociationError {}
#[derive(Debug, PartialEq)]
pub enum DeleteJobError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteJobError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteJobError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteJobError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteJobError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteJobError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteJobError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteJobError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteJobError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteJobError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteJobError {}
#[derive(Debug, PartialEq)]
pub enum DeleteWebhookError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl DeleteWebhookError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteWebhookError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(DeleteWebhookError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(DeleteWebhookError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteWebhookError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(DeleteWebhookError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(DeleteWebhookError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteWebhookError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteWebhookError::BadRequest(ref cause) => write!(f, "{}", cause),
DeleteWebhookError::InternalFailure(ref cause) => write!(f, "{}", cause),
DeleteWebhookError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteWebhookError::NotFound(ref cause) => write!(f, "{}", cause),
DeleteWebhookError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteWebhookError {}
#[derive(Debug, PartialEq)]
pub enum GenerateAccessLogsError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl GenerateAccessLogsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GenerateAccessLogsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GenerateAccessLogsError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GenerateAccessLogsError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GenerateAccessLogsError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GenerateAccessLogsError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GenerateAccessLogsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GenerateAccessLogsError::BadRequest(ref cause) => write!(f, "{}", cause),
GenerateAccessLogsError::InternalFailure(ref cause) => write!(f, "{}", cause),
GenerateAccessLogsError::NotFound(ref cause) => write!(f, "{}", cause),
GenerateAccessLogsError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GenerateAccessLogsError {}
#[derive(Debug, PartialEq)]
pub enum GetAppError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl GetAppError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAppError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetAppError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetAppError::InternalFailure(err.msg))
}
"NotFoundException" => return RusotoError::Service(GetAppError::NotFound(err.msg)),
"UnauthorizedException" => {
return RusotoError::Service(GetAppError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAppError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAppError::BadRequest(ref cause) => write!(f, "{}", cause),
GetAppError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetAppError::NotFound(ref cause) => write!(f, "{}", cause),
GetAppError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAppError {}
#[derive(Debug, PartialEq)]
pub enum GetArtifactUrlError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl GetArtifactUrlError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetArtifactUrlError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetArtifactUrlError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetArtifactUrlError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetArtifactUrlError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetArtifactUrlError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetArtifactUrlError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetArtifactUrlError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetArtifactUrlError::BadRequest(ref cause) => write!(f, "{}", cause),
GetArtifactUrlError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetArtifactUrlError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetArtifactUrlError::NotFound(ref cause) => write!(f, "{}", cause),
GetArtifactUrlError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetArtifactUrlError {}
#[derive(Debug, PartialEq)]
pub enum GetBackendEnvironmentError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl GetBackendEnvironmentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBackendEnvironmentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetBackendEnvironmentError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetBackendEnvironmentError::InternalFailure(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetBackendEnvironmentError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetBackendEnvironmentError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBackendEnvironmentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBackendEnvironmentError::BadRequest(ref cause) => write!(f, "{}", cause),
GetBackendEnvironmentError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetBackendEnvironmentError::NotFound(ref cause) => write!(f, "{}", cause),
GetBackendEnvironmentError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBackendEnvironmentError {}
#[derive(Debug, PartialEq)]
pub enum GetBranchError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl GetBranchError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBranchError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetBranchError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetBranchError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetBranchError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetBranchError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBranchError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBranchError::BadRequest(ref cause) => write!(f, "{}", cause),
GetBranchError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetBranchError::NotFound(ref cause) => write!(f, "{}", cause),
GetBranchError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBranchError {}
#[derive(Debug, PartialEq)]
pub enum GetDomainAssociationError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl GetDomainAssociationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDomainAssociationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetDomainAssociationError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetDomainAssociationError::InternalFailure(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(GetDomainAssociationError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetDomainAssociationError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDomainAssociationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDomainAssociationError::BadRequest(ref cause) => write!(f, "{}", cause),
GetDomainAssociationError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetDomainAssociationError::NotFound(ref cause) => write!(f, "{}", cause),
GetDomainAssociationError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDomainAssociationError {}
#[derive(Debug, PartialEq)]
pub enum GetJobError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl GetJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetJobError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetJobError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetJobError::LimitExceeded(err.msg))
}
"NotFoundException" => return RusotoError::Service(GetJobError::NotFound(err.msg)),
"UnauthorizedException" => {
return RusotoError::Service(GetJobError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetJobError::BadRequest(ref cause) => write!(f, "{}", cause),
GetJobError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetJobError::NotFound(ref cause) => write!(f, "{}", cause),
GetJobError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetJobError {}
#[derive(Debug, PartialEq)]
pub enum GetWebhookError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl GetWebhookError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetWebhookError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(GetWebhookError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(GetWebhookError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetWebhookError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(GetWebhookError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(GetWebhookError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetWebhookError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetWebhookError::BadRequest(ref cause) => write!(f, "{}", cause),
GetWebhookError::InternalFailure(ref cause) => write!(f, "{}", cause),
GetWebhookError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetWebhookError::NotFound(ref cause) => write!(f, "{}", cause),
GetWebhookError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetWebhookError {}
#[derive(Debug, PartialEq)]
pub enum ListAppsError {
BadRequest(String),
InternalFailure(String),
Unauthorized(String),
}
impl ListAppsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAppsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListAppsError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListAppsError::InternalFailure(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListAppsError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAppsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAppsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListAppsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListAppsError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListAppsError {}
#[derive(Debug, PartialEq)]
pub enum ListArtifactsError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
Unauthorized(String),
}
impl ListArtifactsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListArtifactsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListArtifactsError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListArtifactsError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListArtifactsError::LimitExceeded(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListArtifactsError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListArtifactsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListArtifactsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListArtifactsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListArtifactsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListArtifactsError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListArtifactsError {}
#[derive(Debug, PartialEq)]
pub enum ListBackendEnvironmentsError {
BadRequest(String),
InternalFailure(String),
Unauthorized(String),
}
impl ListBackendEnvironmentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBackendEnvironmentsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListBackendEnvironmentsError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListBackendEnvironmentsError::InternalFailure(
err.msg,
))
}
"UnauthorizedException" => {
return RusotoError::Service(ListBackendEnvironmentsError::Unauthorized(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBackendEnvironmentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBackendEnvironmentsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListBackendEnvironmentsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListBackendEnvironmentsError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBackendEnvironmentsError {}
#[derive(Debug, PartialEq)]
pub enum ListBranchesError {
BadRequest(String),
InternalFailure(String),
Unauthorized(String),
}
impl ListBranchesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBranchesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListBranchesError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListBranchesError::InternalFailure(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListBranchesError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListBranchesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListBranchesError::BadRequest(ref cause) => write!(f, "{}", cause),
ListBranchesError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListBranchesError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBranchesError {}
#[derive(Debug, PartialEq)]
pub enum ListDomainAssociationsError {
BadRequest(String),
InternalFailure(String),
Unauthorized(String),
}
impl ListDomainAssociationsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDomainAssociationsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListDomainAssociationsError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListDomainAssociationsError::InternalFailure(
err.msg,
))
}
"UnauthorizedException" => {
return RusotoError::Service(ListDomainAssociationsError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDomainAssociationsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDomainAssociationsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListDomainAssociationsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListDomainAssociationsError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDomainAssociationsError {}
#[derive(Debug, PartialEq)]
pub enum ListJobsError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
Unauthorized(String),
}
impl ListJobsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListJobsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListJobsError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListJobsError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListJobsError::LimitExceeded(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListJobsError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListJobsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListJobsError::BadRequest(ref cause) => write!(f, "{}", cause),
ListJobsError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListJobsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListJobsError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListJobsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
BadRequest(String),
InternalFailure(String),
ResourceNotFound(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListTagsForResourceError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListTagsForResourceError::InternalFailure(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListWebhooksError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
Unauthorized(String),
}
impl ListWebhooksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListWebhooksError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(ListWebhooksError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(ListWebhooksError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListWebhooksError::LimitExceeded(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(ListWebhooksError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListWebhooksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListWebhooksError::BadRequest(ref cause) => write!(f, "{}", cause),
ListWebhooksError::InternalFailure(ref cause) => write!(f, "{}", cause),
ListWebhooksError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListWebhooksError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListWebhooksError {}
#[derive(Debug, PartialEq)]
pub enum StartDeploymentError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl StartDeploymentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartDeploymentError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StartDeploymentError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(StartDeploymentError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(StartDeploymentError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(StartDeploymentError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(StartDeploymentError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartDeploymentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartDeploymentError::BadRequest(ref cause) => write!(f, "{}", cause),
StartDeploymentError::InternalFailure(ref cause) => write!(f, "{}", cause),
StartDeploymentError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StartDeploymentError::NotFound(ref cause) => write!(f, "{}", cause),
StartDeploymentError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartDeploymentError {}
#[derive(Debug, PartialEq)]
pub enum StartJobError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl StartJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StartJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StartJobError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(StartJobError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(StartJobError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(StartJobError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(StartJobError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StartJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StartJobError::BadRequest(ref cause) => write!(f, "{}", cause),
StartJobError::InternalFailure(ref cause) => write!(f, "{}", cause),
StartJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StartJobError::NotFound(ref cause) => write!(f, "{}", cause),
StartJobError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StartJobError {}
#[derive(Debug, PartialEq)]
pub enum StopJobError {
BadRequest(String),
InternalFailure(String),
LimitExceeded(String),
NotFound(String),
Unauthorized(String),
}
impl StopJobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<StopJobError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(StopJobError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(StopJobError::InternalFailure(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(StopJobError::LimitExceeded(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(StopJobError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(StopJobError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for StopJobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
StopJobError::BadRequest(ref cause) => write!(f, "{}", cause),
StopJobError::InternalFailure(ref cause) => write!(f, "{}", cause),
StopJobError::LimitExceeded(ref cause) => write!(f, "{}", cause),
StopJobError::NotFound(ref cause) => write!(f, "{}", cause),
StopJobError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for StopJobError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
BadRequest(String),
InternalFailure(String),
ResourceNotFound(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(TagResourceError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(TagResourceError::InternalFailure(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
BadRequest(String),
InternalFailure(String),
ResourceNotFound(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UntagResourceError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(UntagResourceError::InternalFailure(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::BadRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::InternalFailure(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateAppError {
BadRequest(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl UpdateAppError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateAppError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateAppError::BadRequest(err.msg))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateAppError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateAppError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateAppError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateAppError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateAppError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateAppError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateAppError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateAppError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateAppError {}
#[derive(Debug, PartialEq)]
pub enum UpdateBranchError {
BadRequest(String),
DependentServiceFailure(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl UpdateBranchError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateBranchError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateBranchError::BadRequest(err.msg))
}
"DependentServiceFailureException" => {
return RusotoError::Service(UpdateBranchError::DependentServiceFailure(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateBranchError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateBranchError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateBranchError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateBranchError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateBranchError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateBranchError::DependentServiceFailure(ref cause) => write!(f, "{}", cause),
UpdateBranchError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateBranchError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateBranchError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateBranchError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDomainAssociationError {
BadRequest(String),
DependentServiceFailure(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl UpdateDomainAssociationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDomainAssociationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateDomainAssociationError::BadRequest(err.msg))
}
"DependentServiceFailureException" => {
return RusotoError::Service(
UpdateDomainAssociationError::DependentServiceFailure(err.msg),
)
}
"InternalFailureException" => {
return RusotoError::Service(UpdateDomainAssociationError::InternalFailure(
err.msg,
))
}
"NotFoundException" => {
return RusotoError::Service(UpdateDomainAssociationError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateDomainAssociationError::Unauthorized(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDomainAssociationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDomainAssociationError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateDomainAssociationError::DependentServiceFailure(ref cause) => {
write!(f, "{}", cause)
}
UpdateDomainAssociationError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateDomainAssociationError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateDomainAssociationError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDomainAssociationError {}
#[derive(Debug, PartialEq)]
pub enum UpdateWebhookError {
BadRequest(String),
DependentServiceFailure(String),
InternalFailure(String),
NotFound(String),
Unauthorized(String),
}
impl UpdateWebhookError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateWebhookError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"BadRequestException" => {
return RusotoError::Service(UpdateWebhookError::BadRequest(err.msg))
}
"DependentServiceFailureException" => {
return RusotoError::Service(UpdateWebhookError::DependentServiceFailure(
err.msg,
))
}
"InternalFailureException" => {
return RusotoError::Service(UpdateWebhookError::InternalFailure(err.msg))
}
"NotFoundException" => {
return RusotoError::Service(UpdateWebhookError::NotFound(err.msg))
}
"UnauthorizedException" => {
return RusotoError::Service(UpdateWebhookError::Unauthorized(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateWebhookError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateWebhookError::BadRequest(ref cause) => write!(f, "{}", cause),
UpdateWebhookError::DependentServiceFailure(ref cause) => write!(f, "{}", cause),
UpdateWebhookError::InternalFailure(ref cause) => write!(f, "{}", cause),
UpdateWebhookError::NotFound(ref cause) => write!(f, "{}", cause),
UpdateWebhookError::Unauthorized(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateWebhookError {}
#[async_trait]
pub trait Amplify {
async fn create_app(
&self,
input: CreateAppRequest,
) -> Result<CreateAppResult, RusotoError<CreateAppError>>;
async fn create_backend_environment(
&self,
input: CreateBackendEnvironmentRequest,
) -> Result<CreateBackendEnvironmentResult, RusotoError<CreateBackendEnvironmentError>>;
async fn create_branch(
&self,
input: CreateBranchRequest,
) -> Result<CreateBranchResult, RusotoError<CreateBranchError>>;
async fn create_deployment(
&self,
input: CreateDeploymentRequest,
) -> Result<CreateDeploymentResult, RusotoError<CreateDeploymentError>>;
async fn create_domain_association(
&self,
input: CreateDomainAssociationRequest,
) -> Result<CreateDomainAssociationResult, RusotoError<CreateDomainAssociationError>>;
async fn create_webhook(
&self,
input: CreateWebhookRequest,
) -> Result<CreateWebhookResult, RusotoError<CreateWebhookError>>;
async fn delete_app(
&self,
input: DeleteAppRequest,
) -> Result<DeleteAppResult, RusotoError<DeleteAppError>>;
async fn delete_backend_environment(
&self,
input: DeleteBackendEnvironmentRequest,
) -> Result<DeleteBackendEnvironmentResult, RusotoError<DeleteBackendEnvironmentError>>;
async fn delete_branch(
&self,
input: DeleteBranchRequest,
) -> Result<DeleteBranchResult, RusotoError<DeleteBranchError>>;
async fn delete_domain_association(
&self,
input: DeleteDomainAssociationRequest,
) -> Result<DeleteDomainAssociationResult, RusotoError<DeleteDomainAssociationError>>;
async fn delete_job(
&self,
input: DeleteJobRequest,
) -> Result<DeleteJobResult, RusotoError<DeleteJobError>>;
async fn delete_webhook(
&self,
input: DeleteWebhookRequest,
) -> Result<DeleteWebhookResult, RusotoError<DeleteWebhookError>>;
async fn generate_access_logs(
&self,
input: GenerateAccessLogsRequest,
) -> Result<GenerateAccessLogsResult, RusotoError<GenerateAccessLogsError>>;
async fn get_app(&self, input: GetAppRequest)
-> Result<GetAppResult, RusotoError<GetAppError>>;
async fn get_artifact_url(
&self,
input: GetArtifactUrlRequest,
) -> Result<GetArtifactUrlResult, RusotoError<GetArtifactUrlError>>;
async fn get_backend_environment(
&self,
input: GetBackendEnvironmentRequest,
) -> Result<GetBackendEnvironmentResult, RusotoError<GetBackendEnvironmentError>>;
async fn get_branch(
&self,
input: GetBranchRequest,
) -> Result<GetBranchResult, RusotoError<GetBranchError>>;
async fn get_domain_association(
&self,
input: GetDomainAssociationRequest,
) -> Result<GetDomainAssociationResult, RusotoError<GetDomainAssociationError>>;
async fn get_job(&self, input: GetJobRequest)
-> Result<GetJobResult, RusotoError<GetJobError>>;
async fn get_webhook(
&self,
input: GetWebhookRequest,
) -> Result<GetWebhookResult, RusotoError<GetWebhookError>>;
async fn list_apps(
&self,
input: ListAppsRequest,
) -> Result<ListAppsResult, RusotoError<ListAppsError>>;
async fn list_artifacts(
&self,
input: ListArtifactsRequest,
) -> Result<ListArtifactsResult, RusotoError<ListArtifactsError>>;
async fn list_backend_environments(
&self,
input: ListBackendEnvironmentsRequest,
) -> Result<ListBackendEnvironmentsResult, RusotoError<ListBackendEnvironmentsError>>;
async fn list_branches(
&self,
input: ListBranchesRequest,
) -> Result<ListBranchesResult, RusotoError<ListBranchesError>>;
async fn list_domain_associations(
&self,
input: ListDomainAssociationsRequest,
) -> Result<ListDomainAssociationsResult, RusotoError<ListDomainAssociationsError>>;
async fn list_jobs(
&self,
input: ListJobsRequest,
) -> Result<ListJobsResult, RusotoError<ListJobsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_webhooks(
&self,
input: ListWebhooksRequest,
) -> Result<ListWebhooksResult, RusotoError<ListWebhooksError>>;
async fn start_deployment(
&self,
input: StartDeploymentRequest,
) -> Result<StartDeploymentResult, RusotoError<StartDeploymentError>>;
async fn start_job(
&self,
input: StartJobRequest,
) -> Result<StartJobResult, RusotoError<StartJobError>>;
async fn stop_job(
&self,
input: StopJobRequest,
) -> Result<StopJobResult, RusotoError<StopJobError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_app(
&self,
input: UpdateAppRequest,
) -> Result<UpdateAppResult, RusotoError<UpdateAppError>>;
async fn update_branch(
&self,
input: UpdateBranchRequest,
) -> Result<UpdateBranchResult, RusotoError<UpdateBranchError>>;
async fn update_domain_association(
&self,
input: UpdateDomainAssociationRequest,
) -> Result<UpdateDomainAssociationResult, RusotoError<UpdateDomainAssociationError>>;
async fn update_webhook(
&self,
input: UpdateWebhookRequest,
) -> Result<UpdateWebhookResult, RusotoError<UpdateWebhookError>>;
}
#[derive(Clone)]
pub struct AmplifyClient {
client: Client,
region: region::Region,
}
impl AmplifyClient {
pub fn new(region: region::Region) -> AmplifyClient {
AmplifyClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> AmplifyClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
AmplifyClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> AmplifyClient {
AmplifyClient { client, region }
}
}
#[async_trait]
impl Amplify for AmplifyClient {
#[allow(unused_mut)]
async fn create_app(
&self,
input: CreateAppRequest,
) -> Result<CreateAppResult, RusotoError<CreateAppError>> {
let request_uri = "/apps";
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<CreateAppResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateAppError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_backend_environment(
&self,
input: CreateBackendEnvironmentRequest,
) -> Result<CreateBackendEnvironmentResult, RusotoError<CreateBackendEnvironmentError>> {
let request_uri = format!("/apps/{app_id}/backendenvironments", app_id = input.app_id);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateBackendEnvironmentResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateBackendEnvironmentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_branch(
&self,
input: CreateBranchRequest,
) -> Result<CreateBranchResult, RusotoError<CreateBranchError>> {
let request_uri = format!("/apps/{app_id}/branches", app_id = input.app_id);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateBranchResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateBranchError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_deployment(
&self,
input: CreateDeploymentRequest,
) -> Result<CreateDeploymentResult, RusotoError<CreateDeploymentError>> {
let request_uri = format!(
"/apps/{app_id}/branches/{branch_name}/deployments",
app_id = input.app_id,
branch_name = input.branch_name
);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDeploymentResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_domain_association(
&self,
input: CreateDomainAssociationRequest,
) -> Result<CreateDomainAssociationResult, RusotoError<CreateDomainAssociationError>> {
let request_uri = format!("/apps/{app_id}/domains", app_id = input.app_id);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDomainAssociationResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDomainAssociationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_webhook(
&self,
input: CreateWebhookRequest,
) -> Result<CreateWebhookResult, RusotoError<CreateWebhookError>> {
let request_uri = format!("/apps/{app_id}/webhooks", app_id = input.app_id);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateWebhookResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateWebhookError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_app(
&self,
input: DeleteAppRequest,
) -> Result<DeleteAppResult, RusotoError<DeleteAppError>> {
let request_uri = format!("/apps/{app_id}", app_id = input.app_id);
let mut request = SignedRequest::new("DELETE", "amplify", &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::<DeleteAppResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteAppError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_backend_environment(
&self,
input: DeleteBackendEnvironmentRequest,
) -> Result<DeleteBackendEnvironmentResult, RusotoError<DeleteBackendEnvironmentError>> {
let request_uri = format!(
"/apps/{app_id}/backendenvironments/{environment_name}",
app_id = input.app_id,
environment_name = input.environment_name
);
let mut request = SignedRequest::new("DELETE", "amplify", &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::<DeleteBackendEnvironmentResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteBackendEnvironmentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_branch(
&self,
input: DeleteBranchRequest,
) -> Result<DeleteBranchResult, RusotoError<DeleteBranchError>> {
let request_uri = format!(
"/apps/{app_id}/branches/{branch_name}",
app_id = input.app_id,
branch_name = input.branch_name
);
let mut request = SignedRequest::new("DELETE", "amplify", &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::<DeleteBranchResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteBranchError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_domain_association(
&self,
input: DeleteDomainAssociationRequest,
) -> Result<DeleteDomainAssociationResult, RusotoError<DeleteDomainAssociationError>> {
let request_uri = format!(
"/apps/{app_id}/domains/{domain_name}",
app_id = input.app_id,
domain_name = input.domain_name
);
let mut request = SignedRequest::new("DELETE", "amplify", &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::<DeleteDomainAssociationResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDomainAssociationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_job(
&self,
input: DeleteJobRequest,
) -> Result<DeleteJobResult, RusotoError<DeleteJobError>> {
let request_uri = format!(
"/apps/{app_id}/branches/{branch_name}/jobs/{job_id}",
app_id = input.app_id,
branch_name = input.branch_name,
job_id = input.job_id
);
let mut request = SignedRequest::new("DELETE", "amplify", &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::<DeleteJobResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_webhook(
&self,
input: DeleteWebhookRequest,
) -> Result<DeleteWebhookResult, RusotoError<DeleteWebhookError>> {
let request_uri = format!("/webhooks/{webhook_id}", webhook_id = input.webhook_id);
let mut request = SignedRequest::new("DELETE", "amplify", &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::<DeleteWebhookResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteWebhookError::from_response(response))
}
}
#[allow(unused_mut)]
async fn generate_access_logs(
&self,
input: GenerateAccessLogsRequest,
) -> Result<GenerateAccessLogsResult, RusotoError<GenerateAccessLogsError>> {
let request_uri = format!("/apps/{app_id}/accesslogs", app_id = input.app_id);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GenerateAccessLogsResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GenerateAccessLogsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_app(
&self,
input: GetAppRequest,
) -> Result<GetAppResult, RusotoError<GetAppError>> {
let request_uri = format!("/apps/{app_id}", app_id = input.app_id);
let mut request = SignedRequest::new("GET", "amplify", &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::<GetAppResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetAppError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_artifact_url(
&self,
input: GetArtifactUrlRequest,
) -> Result<GetArtifactUrlResult, RusotoError<GetArtifactUrlError>> {
let request_uri = format!("/artifacts/{artifact_id}", artifact_id = input.artifact_id);
let mut request = SignedRequest::new("GET", "amplify", &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::<GetArtifactUrlResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetArtifactUrlError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_backend_environment(
&self,
input: GetBackendEnvironmentRequest,
) -> Result<GetBackendEnvironmentResult, RusotoError<GetBackendEnvironmentError>> {
let request_uri = format!(
"/apps/{app_id}/backendenvironments/{environment_name}",
app_id = input.app_id,
environment_name = input.environment_name
);
let mut request = SignedRequest::new("GET", "amplify", &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::<GetBackendEnvironmentResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetBackendEnvironmentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_branch(
&self,
input: GetBranchRequest,
) -> Result<GetBranchResult, RusotoError<GetBranchError>> {
let request_uri = format!(
"/apps/{app_id}/branches/{branch_name}",
app_id = input.app_id,
branch_name = input.branch_name
);
let mut request = SignedRequest::new("GET", "amplify", &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::<GetBranchResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetBranchError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_domain_association(
&self,
input: GetDomainAssociationRequest,
) -> Result<GetDomainAssociationResult, RusotoError<GetDomainAssociationError>> {
let request_uri = format!(
"/apps/{app_id}/domains/{domain_name}",
app_id = input.app_id,
domain_name = input.domain_name
);
let mut request = SignedRequest::new("GET", "amplify", &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::<GetDomainAssociationResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDomainAssociationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_job(
&self,
input: GetJobRequest,
) -> Result<GetJobResult, RusotoError<GetJobError>> {
let request_uri = format!(
"/apps/{app_id}/branches/{branch_name}/jobs/{job_id}",
app_id = input.app_id,
branch_name = input.branch_name,
job_id = input.job_id
);
let mut request = SignedRequest::new("GET", "amplify", &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::<GetJobResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_webhook(
&self,
input: GetWebhookRequest,
) -> Result<GetWebhookResult, RusotoError<GetWebhookError>> {
let request_uri = format!("/webhooks/{webhook_id}", webhook_id = input.webhook_id);
let mut request = SignedRequest::new("GET", "amplify", &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::<GetWebhookResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetWebhookError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_apps(
&self,
input: ListAppsRequest,
) -> Result<ListAppsResult, RusotoError<ListAppsError>> {
let request_uri = "/apps";
let mut request = SignedRequest::new("GET", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<ListAppsResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListAppsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_artifacts(
&self,
input: ListArtifactsRequest,
) -> Result<ListArtifactsResult, RusotoError<ListArtifactsError>> {
let request_uri = format!(
"/apps/{app_id}/branches/{branch_name}/jobs/{job_id}/artifacts",
app_id = input.app_id,
branch_name = input.branch_name,
job_id = input.job_id
);
let mut request = SignedRequest::new("GET", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListArtifactsResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListArtifactsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_backend_environments(
&self,
input: ListBackendEnvironmentsRequest,
) -> Result<ListBackendEnvironmentsResult, RusotoError<ListBackendEnvironmentsError>> {
let request_uri = format!("/apps/{app_id}/backendenvironments", app_id = input.app_id);
let mut request = SignedRequest::new("GET", "amplify", &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.environment_name {
params.put("environmentName", x);
}
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListBackendEnvironmentsResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListBackendEnvironmentsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_branches(
&self,
input: ListBranchesRequest,
) -> Result<ListBranchesResult, RusotoError<ListBranchesError>> {
let request_uri = format!("/apps/{app_id}/branches", app_id = input.app_id);
let mut request = SignedRequest::new("GET", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListBranchesResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListBranchesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_domain_associations(
&self,
input: ListDomainAssociationsRequest,
) -> Result<ListDomainAssociationsResult, RusotoError<ListDomainAssociationsError>> {
let request_uri = format!("/apps/{app_id}/domains", app_id = input.app_id);
let mut request = SignedRequest::new("GET", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDomainAssociationsResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDomainAssociationsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_jobs(
&self,
input: ListJobsRequest,
) -> Result<ListJobsResult, RusotoError<ListJobsError>> {
let request_uri = format!(
"/apps/{app_id}/branches/{branch_name}/jobs",
app_id = input.app_id,
branch_name = input.branch_name
);
let mut request = SignedRequest::new("GET", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<ListJobsResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListJobsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("GET", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_webhooks(
&self,
input: ListWebhooksRequest,
) -> Result<ListWebhooksResult, RusotoError<ListWebhooksError>> {
let request_uri = format!("/apps/{app_id}/webhooks", app_id = input.app_id);
let mut request = SignedRequest::new("GET", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
if let Some(ref x) = input.max_results {
params.put("maxResults", x);
}
if let Some(ref x) = input.next_token {
params.put("nextToken", x);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListWebhooksResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListWebhooksError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_deployment(
&self,
input: StartDeploymentRequest,
) -> Result<StartDeploymentResult, RusotoError<StartDeploymentError>> {
let request_uri = format!(
"/apps/{app_id}/branches/{branch_name}/deployments/start",
app_id = input.app_id,
branch_name = input.branch_name
);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<StartDeploymentResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartDeploymentError::from_response(response))
}
}
#[allow(unused_mut)]
async fn start_job(
&self,
input: StartJobRequest,
) -> Result<StartJobResult, RusotoError<StartJobError>> {
let request_uri = format!(
"/apps/{app_id}/branches/{branch_name}/jobs",
app_id = input.app_id,
branch_name = input.branch_name
);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<StartJobResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StartJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn stop_job(
&self,
input: StopJobRequest,
) -> Result<StopJobResult, RusotoError<StopJobError>> {
let request_uri = format!(
"/apps/{app_id}/branches/{branch_name}/jobs/{job_id}/stop",
app_id = input.app_id,
branch_name = input.branch_name,
job_id = input.job_id
);
let mut request = SignedRequest::new("DELETE", "amplify", &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::<StopJobResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(StopJobError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<TagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let request_uri = format!("/tags/{resource_arn}", resource_arn = input.resource_arn);
let mut request = SignedRequest::new("DELETE", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let mut params = Params::new();
for item in input.tag_keys.iter() {
params.put("tagKeys", item);
}
request.set_params(params);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_app(
&self,
input: UpdateAppRequest,
) -> Result<UpdateAppResult, RusotoError<UpdateAppError>> {
let request_uri = format!("/apps/{app_id}", app_id = input.app_id);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result =
proto::json::ResponsePayload::new(&response).deserialize::<UpdateAppResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateAppError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_branch(
&self,
input: UpdateBranchRequest,
) -> Result<UpdateBranchResult, RusotoError<UpdateBranchError>> {
let request_uri = format!(
"/apps/{app_id}/branches/{branch_name}",
app_id = input.app_id,
branch_name = input.branch_name
);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateBranchResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateBranchError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_domain_association(
&self,
input: UpdateDomainAssociationRequest,
) -> Result<UpdateDomainAssociationResult, RusotoError<UpdateDomainAssociationError>> {
let request_uri = format!(
"/apps/{app_id}/domains/{domain_name}",
app_id = input.app_id,
domain_name = input.domain_name
);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateDomainAssociationResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateDomainAssociationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_webhook(
&self,
input: UpdateWebhookRequest,
) -> Result<UpdateWebhookResult, RusotoError<UpdateWebhookError>> {
let request_uri = format!("/webhooks/{webhook_id}", webhook_id = input.webhook_id);
let mut request = SignedRequest::new("POST", "amplify", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.is_success() {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateWebhookResult, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateWebhookError::from_response(response))
}
}
}