use std::error::Error;
use std::fmt;
use async_trait::async_trait;
use rusoto_core::credential::ProvideAwsCredentials;
use rusoto_core::region;
use rusoto_core::request::{BufferedHttpResponse, DispatchSignedRequest};
use rusoto_core::{Client, RusotoError};
use rusoto_core::proto;
use rusoto_core::request::HttpResponse;
use rusoto_core::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
impl CodeCommitClient {
fn new_signed_request(&self, http_method: &str, request_uri: &str) -> SignedRequest {
let mut request = SignedRequest::new(http_method, "codecommit", &self.region, request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request
}
async fn sign_and_dispatch<E>(
&self,
request: SignedRequest,
from_response: fn(BufferedHttpResponse) -> RusotoError<E>,
) -> Result<HttpResponse, RusotoError<E>> {
let mut response = self.client.sign_and_dispatch(request).await?;
if !response.status.is_success() {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
return Err(from_response(response));
}
Ok(response)
}
}
use serde_json;
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Approval {
#[serde(rename = "approvalState")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_state: Option<String>,
#[serde(rename = "userArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub user_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApprovalRule {
#[serde(rename = "approvalRuleContent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_content: Option<String>,
#[serde(rename = "approvalRuleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_id: Option<String>,
#[serde(rename = "approvalRuleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_name: Option<String>,
#[serde(rename = "creationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "lastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "lastModifiedUser")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_user: Option<String>,
#[serde(rename = "originApprovalRuleTemplate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub origin_approval_rule_template: Option<OriginApprovalRuleTemplate>,
#[serde(rename = "ruleContentSha256")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rule_content_sha_256: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApprovalRuleEventMetadata {
#[serde(rename = "approvalRuleContent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_content: Option<String>,
#[serde(rename = "approvalRuleId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_id: Option<String>,
#[serde(rename = "approvalRuleName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApprovalRuleOverriddenEventMetadata {
#[serde(rename = "overrideStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub override_status: Option<String>,
#[serde(rename = "revisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApprovalRuleTemplate {
#[serde(rename = "approvalRuleTemplateContent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_template_content: Option<String>,
#[serde(rename = "approvalRuleTemplateDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_template_description: Option<String>,
#[serde(rename = "approvalRuleTemplateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_template_id: Option<String>,
#[serde(rename = "approvalRuleTemplateName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_template_name: Option<String>,
#[serde(rename = "creationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "lastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "lastModifiedUser")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_user: Option<String>,
#[serde(rename = "ruleContentSha256")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rule_content_sha_256: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApprovalStateChangedEventMetadata {
#[serde(rename = "approvalStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_status: Option<String>,
#[serde(rename = "revisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AssociateApprovalRuleTemplateWithRepositoryInput {
#[serde(rename = "approvalRuleTemplateName")]
pub approval_rule_template_name: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CodeCommitBatchAssociateApprovalRuleTemplateWithRepositoriesError {
#[serde(rename = "errorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "errorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchAssociateApprovalRuleTemplateWithRepositoriesInput {
#[serde(rename = "approvalRuleTemplateName")]
pub approval_rule_template_name: String,
#[serde(rename = "repositoryNames")]
pub repository_names: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchAssociateApprovalRuleTemplateWithRepositoriesOutput {
#[serde(rename = "associatedRepositoryNames")]
pub associated_repository_names: Vec<String>,
#[serde(rename = "errors")]
pub errors: Vec<CodeCommitBatchAssociateApprovalRuleTemplateWithRepositoriesError>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CodeCommitBatchDescribeMergeConflictsError {
#[serde(rename = "exceptionName")]
pub exception_name: String,
#[serde(rename = "filePath")]
pub file_path: String,
#[serde(rename = "message")]
pub message: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDescribeMergeConflictsInput {
#[serde(rename = "conflictDetailLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_detail_level: Option<String>,
#[serde(rename = "conflictResolutionStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution_strategy: Option<String>,
#[serde(rename = "destinationCommitSpecifier")]
pub destination_commit_specifier: String,
#[serde(rename = "filePaths")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_paths: Option<Vec<String>>,
#[serde(rename = "maxConflictFiles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_conflict_files: Option<i64>,
#[serde(rename = "maxMergeHunks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_merge_hunks: Option<i64>,
#[serde(rename = "mergeOption")]
pub merge_option: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitSpecifier")]
pub source_commit_specifier: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDescribeMergeConflictsOutput {
#[serde(rename = "baseCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_commit_id: Option<String>,
#[serde(rename = "conflicts")]
pub conflicts: Vec<Conflict>,
#[serde(rename = "destinationCommitId")]
pub destination_commit_id: String,
#[serde(rename = "errors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors: Option<Vec<CodeCommitBatchDescribeMergeConflictsError>>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "sourceCommitId")]
pub source_commit_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CodeCommitBatchDisassociateApprovalRuleTemplateFromRepositoriesError {
#[serde(rename = "errorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "errorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDisassociateApprovalRuleTemplateFromRepositoriesInput {
#[serde(rename = "approvalRuleTemplateName")]
pub approval_rule_template_name: String,
#[serde(rename = "repositoryNames")]
pub repository_names: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput {
#[serde(rename = "disassociatedRepositoryNames")]
pub disassociated_repository_names: Vec<String>,
#[serde(rename = "errors")]
pub errors: Vec<CodeCommitBatchDisassociateApprovalRuleTemplateFromRepositoriesError>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CodeCommitBatchGetCommitsError {
#[serde(rename = "commitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_id: Option<String>,
#[serde(rename = "errorCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_code: Option<String>,
#[serde(rename = "errorMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub error_message: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetCommitsInput {
#[serde(rename = "commitIds")]
pub commit_ids: Vec<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetCommitsOutput {
#[serde(rename = "commits")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commits: Option<Vec<Commit>>,
#[serde(rename = "errors")]
#[serde(skip_serializing_if = "Option::is_none")]
pub errors: Option<Vec<CodeCommitBatchGetCommitsError>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetRepositoriesInput {
#[serde(rename = "repositoryNames")]
pub repository_names: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetRepositoriesOutput {
#[serde(rename = "repositories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repositories: Option<Vec<RepositoryMetadata>>,
#[serde(rename = "repositoriesNotFound")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repositories_not_found: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BlobMetadata {
#[serde(rename = "blobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blob_id: Option<String>,
#[serde(rename = "mode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub mode: Option<String>,
#[serde(rename = "path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BranchInfo {
#[serde(rename = "branchName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub branch_name: Option<String>,
#[serde(rename = "commitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Comment {
#[serde(rename = "authorArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author_arn: Option<String>,
#[serde(rename = "callerReactions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub caller_reactions: Option<Vec<String>>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "commentId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment_id: Option<String>,
#[serde(rename = "content")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content: Option<String>,
#[serde(rename = "creationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "deleted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deleted: Option<bool>,
#[serde(rename = "inReplyTo")]
#[serde(skip_serializing_if = "Option::is_none")]
pub in_reply_to: Option<String>,
#[serde(rename = "lastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "reactionCounts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reaction_counts: Option<::std::collections::HashMap<String, i64>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CommentsForComparedCommit {
#[serde(rename = "afterBlobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_blob_id: Option<String>,
#[serde(rename = "afterCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_commit_id: Option<String>,
#[serde(rename = "beforeBlobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_blob_id: Option<String>,
#[serde(rename = "beforeCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_commit_id: Option<String>,
#[serde(rename = "comments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comments: Option<Vec<Comment>>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<Location>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CommentsForPullRequest {
#[serde(rename = "afterBlobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_blob_id: Option<String>,
#[serde(rename = "afterCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_commit_id: Option<String>,
#[serde(rename = "beforeBlobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_blob_id: Option<String>,
#[serde(rename = "beforeCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_commit_id: Option<String>,
#[serde(rename = "comments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comments: Option<Vec<Comment>>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<Location>,
#[serde(rename = "pullRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Commit {
#[serde(rename = "additionalData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub additional_data: Option<String>,
#[serde(rename = "author")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author: Option<UserInfo>,
#[serde(rename = "commitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_id: Option<String>,
#[serde(rename = "committer")]
#[serde(skip_serializing_if = "Option::is_none")]
pub committer: Option<UserInfo>,
#[serde(rename = "message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "parents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parents: Option<Vec<String>>,
#[serde(rename = "treeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tree_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Conflict {
#[serde(rename = "conflictMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_metadata: Option<ConflictMetadata>,
#[serde(rename = "mergeHunks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merge_hunks: Option<Vec<MergeHunk>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ConflictMetadata {
#[serde(rename = "contentConflict")]
#[serde(skip_serializing_if = "Option::is_none")]
pub content_conflict: Option<bool>,
#[serde(rename = "fileModeConflict")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_mode_conflict: Option<bool>,
#[serde(rename = "fileModes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_modes: Option<FileModes>,
#[serde(rename = "filePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_path: Option<String>,
#[serde(rename = "fileSizes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_sizes: Option<FileSizes>,
#[serde(rename = "isBinaryFile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_binary_file: Option<IsBinaryFile>,
#[serde(rename = "mergeOperations")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merge_operations: Option<MergeOperations>,
#[serde(rename = "numberOfConflicts")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_of_conflicts: Option<i64>,
#[serde(rename = "objectTypeConflict")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_type_conflict: Option<bool>,
#[serde(rename = "objectTypes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_types: Option<ObjectTypes>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ConflictResolution {
#[serde(rename = "deleteFiles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_files: Option<Vec<DeleteFileEntry>>,
#[serde(rename = "replaceContents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub replace_contents: Option<Vec<ReplaceContentEntry>>,
#[serde(rename = "setFileModes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub set_file_modes: Option<Vec<SetFileModeEntry>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateApprovalRuleTemplateInput {
#[serde(rename = "approvalRuleTemplateContent")]
pub approval_rule_template_content: String,
#[serde(rename = "approvalRuleTemplateDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_template_description: Option<String>,
#[serde(rename = "approvalRuleTemplateName")]
pub approval_rule_template_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateApprovalRuleTemplateOutput {
#[serde(rename = "approvalRuleTemplate")]
pub approval_rule_template: ApprovalRuleTemplate,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateBranchInput {
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "commitId")]
pub commit_id: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateCommitInput {
#[serde(rename = "authorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author_name: Option<String>,
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "commitMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_message: Option<String>,
#[serde(rename = "deleteFiles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_files: Option<Vec<DeleteFileEntry>>,
#[serde(rename = "email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "keepEmptyFolders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keep_empty_folders: Option<bool>,
#[serde(rename = "parentCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_commit_id: Option<String>,
#[serde(rename = "putFiles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub put_files: Option<Vec<PutFileEntry>>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "setFileModes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub set_file_modes: Option<Vec<SetFileModeEntry>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateCommitOutput {
#[serde(rename = "commitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_id: Option<String>,
#[serde(rename = "filesAdded")]
#[serde(skip_serializing_if = "Option::is_none")]
pub files_added: Option<Vec<FileMetadata>>,
#[serde(rename = "filesDeleted")]
#[serde(skip_serializing_if = "Option::is_none")]
pub files_deleted: Option<Vec<FileMetadata>>,
#[serde(rename = "filesUpdated")]
#[serde(skip_serializing_if = "Option::is_none")]
pub files_updated: Option<Vec<FileMetadata>>,
#[serde(rename = "treeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tree_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePullRequestApprovalRuleInput {
#[serde(rename = "approvalRuleContent")]
pub approval_rule_content: String,
#[serde(rename = "approvalRuleName")]
pub approval_rule_name: String,
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePullRequestApprovalRuleOutput {
#[serde(rename = "approvalRule")]
pub approval_rule: ApprovalRule,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreatePullRequestInput {
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "targets")]
pub targets: Vec<Target>,
#[serde(rename = "title")]
pub title: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreatePullRequestOutput {
#[serde(rename = "pullRequest")]
pub pull_request: PullRequest,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateRepositoryInput {
#[serde(rename = "repositoryDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_description: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: 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 CreateRepositoryOutput {
#[serde(rename = "repositoryMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_metadata: Option<RepositoryMetadata>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateUnreferencedMergeCommitInput {
#[serde(rename = "authorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author_name: Option<String>,
#[serde(rename = "commitMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_message: Option<String>,
#[serde(rename = "conflictDetailLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_detail_level: Option<String>,
#[serde(rename = "conflictResolution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution: Option<ConflictResolution>,
#[serde(rename = "conflictResolutionStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution_strategy: Option<String>,
#[serde(rename = "destinationCommitSpecifier")]
pub destination_commit_specifier: String,
#[serde(rename = "email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "keepEmptyFolders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keep_empty_folders: Option<bool>,
#[serde(rename = "mergeOption")]
pub merge_option: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitSpecifier")]
pub source_commit_specifier: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateUnreferencedMergeCommitOutput {
#[serde(rename = "commitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_id: Option<String>,
#[serde(rename = "treeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tree_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteApprovalRuleTemplateInput {
#[serde(rename = "approvalRuleTemplateName")]
pub approval_rule_template_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteApprovalRuleTemplateOutput {
#[serde(rename = "approvalRuleTemplateId")]
pub approval_rule_template_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteBranchInput {
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteBranchOutput {
#[serde(rename = "deletedBranch")]
#[serde(skip_serializing_if = "Option::is_none")]
pub deleted_branch: Option<BranchInfo>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteCommentContentInput {
#[serde(rename = "commentId")]
pub comment_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteCommentContentOutput {
#[serde(rename = "comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<Comment>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFileEntry {
#[serde(rename = "filePath")]
pub file_path: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFileInput {
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "commitMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_message: Option<String>,
#[serde(rename = "email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "filePath")]
pub file_path: String,
#[serde(rename = "keepEmptyFolders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keep_empty_folders: Option<bool>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "parentCommitId")]
pub parent_commit_id: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteFileOutput {
#[serde(rename = "blobId")]
pub blob_id: String,
#[serde(rename = "commitId")]
pub commit_id: String,
#[serde(rename = "filePath")]
pub file_path: String,
#[serde(rename = "treeId")]
pub tree_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeletePullRequestApprovalRuleInput {
#[serde(rename = "approvalRuleName")]
pub approval_rule_name: String,
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeletePullRequestApprovalRuleOutput {
#[serde(rename = "approvalRuleId")]
pub approval_rule_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteRepositoryInput {
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteRepositoryOutput {
#[serde(rename = "repositoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribeMergeConflictsInput {
#[serde(rename = "conflictDetailLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_detail_level: Option<String>,
#[serde(rename = "conflictResolutionStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution_strategy: Option<String>,
#[serde(rename = "destinationCommitSpecifier")]
pub destination_commit_specifier: String,
#[serde(rename = "filePath")]
pub file_path: String,
#[serde(rename = "maxMergeHunks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_merge_hunks: Option<i64>,
#[serde(rename = "mergeOption")]
pub merge_option: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitSpecifier")]
pub source_commit_specifier: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribeMergeConflictsOutput {
#[serde(rename = "baseCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_commit_id: Option<String>,
#[serde(rename = "conflictMetadata")]
pub conflict_metadata: ConflictMetadata,
#[serde(rename = "destinationCommitId")]
pub destination_commit_id: String,
#[serde(rename = "mergeHunks")]
pub merge_hunks: Vec<MergeHunk>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "sourceCommitId")]
pub source_commit_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DescribePullRequestEventsInput {
#[serde(rename = "actorArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub actor_arn: 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>,
#[serde(rename = "pullRequestEventType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_event_type: Option<String>,
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DescribePullRequestEventsOutput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "pullRequestEvents")]
pub pull_request_events: Vec<PullRequestEvent>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Difference {
#[serde(rename = "afterBlob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_blob: Option<BlobMetadata>,
#[serde(rename = "beforeBlob")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_blob: Option<BlobMetadata>,
#[serde(rename = "changeType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub change_type: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisassociateApprovalRuleTemplateFromRepositoryInput {
#[serde(rename = "approvalRuleTemplateName")]
pub approval_rule_template_name: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EvaluatePullRequestApprovalRulesInput {
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "revisionId")]
pub revision_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EvaluatePullRequestApprovalRulesOutput {
#[serde(rename = "evaluation")]
pub evaluation: Evaluation,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Evaluation {
#[serde(rename = "approvalRulesNotSatisfied")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rules_not_satisfied: Option<Vec<String>>,
#[serde(rename = "approvalRulesSatisfied")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rules_satisfied: Option<Vec<String>>,
#[serde(rename = "approved")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approved: Option<bool>,
#[serde(rename = "overridden")]
#[serde(skip_serializing_if = "Option::is_none")]
pub overridden: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct File {
#[serde(rename = "absolutePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub absolute_path: Option<String>,
#[serde(rename = "blobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blob_id: Option<String>,
#[serde(rename = "fileMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_mode: Option<String>,
#[serde(rename = "relativePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relative_path: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FileMetadata {
#[serde(rename = "absolutePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub absolute_path: Option<String>,
#[serde(rename = "blobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blob_id: Option<String>,
#[serde(rename = "fileMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_mode: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FileModes {
#[serde(rename = "base")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base: Option<String>,
#[serde(rename = "destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
#[serde(rename = "source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct FileSizes {
#[serde(rename = "base")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base: Option<i64>,
#[serde(rename = "destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<i64>,
#[serde(rename = "source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Folder {
#[serde(rename = "absolutePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub absolute_path: Option<String>,
#[serde(rename = "relativePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relative_path: Option<String>,
#[serde(rename = "treeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tree_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetApprovalRuleTemplateInput {
#[serde(rename = "approvalRuleTemplateName")]
pub approval_rule_template_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetApprovalRuleTemplateOutput {
#[serde(rename = "approvalRuleTemplate")]
pub approval_rule_template: ApprovalRuleTemplate,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBlobInput {
#[serde(rename = "blobId")]
pub blob_id: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBlobOutput {
#[serde(rename = "content")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub content: bytes::Bytes,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetBranchInput {
#[serde(rename = "branchName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub branch_name: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetBranchOutput {
#[serde(rename = "branch")]
#[serde(skip_serializing_if = "Option::is_none")]
pub branch: Option<BranchInfo>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCommentInput {
#[serde(rename = "commentId")]
pub comment_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCommentOutput {
#[serde(rename = "comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<Comment>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCommentReactionsInput {
#[serde(rename = "commentId")]
pub comment_id: String,
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "reactionUserArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reaction_user_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCommentReactionsOutput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "reactionsForComment")]
pub reactions_for_comment: Vec<ReactionForComment>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetCommentsForComparedCommitInput {
#[serde(rename = "afterCommitId")]
pub after_commit_id: String,
#[serde(rename = "beforeCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_commit_id: 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>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCommentsForComparedCommitOutput {
#[serde(rename = "commentsForComparedCommitData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comments_for_compared_commit_data: Option<Vec<CommentsForComparedCommit>>,
#[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 GetCommentsForPullRequestInput {
#[serde(rename = "afterCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_commit_id: Option<String>,
#[serde(rename = "beforeCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_commit_id: 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>,
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCommentsForPullRequestOutput {
#[serde(rename = "commentsForPullRequestData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comments_for_pull_request_data: Option<Vec<CommentsForPullRequest>>,
#[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 GetCommitInput {
#[serde(rename = "commitId")]
pub commit_id: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetCommitOutput {
#[serde(rename = "commit")]
pub commit: Commit,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDifferencesInput {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "afterCommitSpecifier")]
pub after_commit_specifier: String,
#[serde(rename = "afterPath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_path: Option<String>,
#[serde(rename = "beforeCommitSpecifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_commit_specifier: Option<String>,
#[serde(rename = "beforePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_path: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDifferencesOutput {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "differences")]
#[serde(skip_serializing_if = "Option::is_none")]
pub differences: Option<Vec<Difference>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFileInput {
#[serde(rename = "commitSpecifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_specifier: Option<String>,
#[serde(rename = "filePath")]
pub file_path: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFileOutput {
#[serde(rename = "blobId")]
pub blob_id: String,
#[serde(rename = "commitId")]
pub commit_id: String,
#[serde(rename = "fileContent")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub file_content: bytes::Bytes,
#[serde(rename = "fileMode")]
pub file_mode: String,
#[serde(rename = "filePath")]
pub file_path: String,
#[serde(rename = "fileSize")]
pub file_size: i64,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFolderInput {
#[serde(rename = "commitSpecifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_specifier: Option<String>,
#[serde(rename = "folderPath")]
pub folder_path: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFolderOutput {
#[serde(rename = "commitId")]
pub commit_id: String,
#[serde(rename = "files")]
#[serde(skip_serializing_if = "Option::is_none")]
pub files: Option<Vec<File>>,
#[serde(rename = "folderPath")]
pub folder_path: String,
#[serde(rename = "subFolders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sub_folders: Option<Vec<Folder>>,
#[serde(rename = "subModules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sub_modules: Option<Vec<SubModule>>,
#[serde(rename = "symbolicLinks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub symbolic_links: Option<Vec<SymbolicLink>>,
#[serde(rename = "treeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tree_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMergeCommitInput {
#[serde(rename = "conflictDetailLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_detail_level: Option<String>,
#[serde(rename = "conflictResolutionStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution_strategy: Option<String>,
#[serde(rename = "destinationCommitSpecifier")]
pub destination_commit_specifier: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitSpecifier")]
pub source_commit_specifier: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMergeCommitOutput {
#[serde(rename = "baseCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_commit_id: Option<String>,
#[serde(rename = "destinationCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_commit_id: Option<String>,
#[serde(rename = "mergedCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merged_commit_id: Option<String>,
#[serde(rename = "sourceCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_commit_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMergeConflictsInput {
#[serde(rename = "conflictDetailLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_detail_level: Option<String>,
#[serde(rename = "conflictResolutionStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution_strategy: Option<String>,
#[serde(rename = "destinationCommitSpecifier")]
pub destination_commit_specifier: String,
#[serde(rename = "maxConflictFiles")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_conflict_files: Option<i64>,
#[serde(rename = "mergeOption")]
pub merge_option: String,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitSpecifier")]
pub source_commit_specifier: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMergeConflictsOutput {
#[serde(rename = "baseCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base_commit_id: Option<String>,
#[serde(rename = "conflictMetadataList")]
pub conflict_metadata_list: Vec<ConflictMetadata>,
#[serde(rename = "destinationCommitId")]
pub destination_commit_id: String,
#[serde(rename = "mergeable")]
pub mergeable: bool,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "sourceCommitId")]
pub source_commit_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetMergeOptionsInput {
#[serde(rename = "conflictDetailLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_detail_level: Option<String>,
#[serde(rename = "conflictResolutionStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution_strategy: Option<String>,
#[serde(rename = "destinationCommitSpecifier")]
pub destination_commit_specifier: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitSpecifier")]
pub source_commit_specifier: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetMergeOptionsOutput {
#[serde(rename = "baseCommitId")]
pub base_commit_id: String,
#[serde(rename = "destinationCommitId")]
pub destination_commit_id: String,
#[serde(rename = "mergeOptions")]
pub merge_options: Vec<String>,
#[serde(rename = "sourceCommitId")]
pub source_commit_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetPullRequestApprovalStatesInput {
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "revisionId")]
pub revision_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetPullRequestApprovalStatesOutput {
#[serde(rename = "approvals")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approvals: Option<Vec<Approval>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetPullRequestInput {
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetPullRequestOutput {
#[serde(rename = "pullRequest")]
pub pull_request: PullRequest,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetPullRequestOverrideStateInput {
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "revisionId")]
pub revision_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetPullRequestOverrideStateOutput {
#[serde(rename = "overridden")]
#[serde(skip_serializing_if = "Option::is_none")]
pub overridden: Option<bool>,
#[serde(rename = "overrider")]
#[serde(skip_serializing_if = "Option::is_none")]
pub overrider: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRepositoryInput {
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRepositoryOutput {
#[serde(rename = "repositoryMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_metadata: Option<RepositoryMetadata>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetRepositoryTriggersInput {
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetRepositoryTriggersOutput {
#[serde(rename = "configurationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_id: Option<String>,
#[serde(rename = "triggers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub triggers: Option<Vec<RepositoryTrigger>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IsBinaryFile {
#[serde(rename = "base")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base: Option<bool>,
#[serde(rename = "destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<bool>,
#[serde(rename = "source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<bool>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListApprovalRuleTemplatesInput {
#[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 ListApprovalRuleTemplatesOutput {
#[serde(rename = "approvalRuleTemplateNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_template_names: Option<Vec<String>>,
#[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 ListAssociatedApprovalRuleTemplatesForRepositoryInput {
#[serde(rename = "maxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAssociatedApprovalRuleTemplatesForRepositoryOutput {
#[serde(rename = "approvalRuleTemplateNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_template_names: Option<Vec<String>>,
#[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 ListBranchesInput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListBranchesOutput {
#[serde(rename = "branches")]
#[serde(skip_serializing_if = "Option::is_none")]
pub branches: Option<Vec<String>>,
#[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 ListPullRequestsInput {
#[serde(rename = "authorArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author_arn: 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>,
#[serde(rename = "pullRequestStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_status: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPullRequestsOutput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "pullRequestIds")]
pub pull_request_ids: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRepositoriesForApprovalRuleTemplateInput {
#[serde(rename = "approvalRuleTemplateName")]
pub approval_rule_template_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 ListRepositoriesForApprovalRuleTemplateOutput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "repositoryNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_names: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListRepositoriesInput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "order")]
#[serde(skip_serializing_if = "Option::is_none")]
pub order: Option<String>,
#[serde(rename = "sortBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub sort_by: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListRepositoriesOutput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "repositories")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repositories: Option<Vec<RepositoryNameIdPair>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceInput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "resourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceOutput {
#[serde(rename = "nextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: 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, Serialize)]
pub struct Location {
#[serde(rename = "filePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_path: Option<String>,
#[serde(rename = "filePosition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_position: Option<i64>,
#[serde(rename = "relativeFileVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relative_file_version: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MergeBranchesByFastForwardInput {
#[serde(rename = "destinationCommitSpecifier")]
pub destination_commit_specifier: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitSpecifier")]
pub source_commit_specifier: String,
#[serde(rename = "targetBranch")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_branch: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MergeBranchesByFastForwardOutput {
#[serde(rename = "commitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_id: Option<String>,
#[serde(rename = "treeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tree_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MergeBranchesBySquashInput {
#[serde(rename = "authorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author_name: Option<String>,
#[serde(rename = "commitMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_message: Option<String>,
#[serde(rename = "conflictDetailLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_detail_level: Option<String>,
#[serde(rename = "conflictResolution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution: Option<ConflictResolution>,
#[serde(rename = "conflictResolutionStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution_strategy: Option<String>,
#[serde(rename = "destinationCommitSpecifier")]
pub destination_commit_specifier: String,
#[serde(rename = "email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "keepEmptyFolders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keep_empty_folders: Option<bool>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitSpecifier")]
pub source_commit_specifier: String,
#[serde(rename = "targetBranch")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_branch: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MergeBranchesBySquashOutput {
#[serde(rename = "commitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_id: Option<String>,
#[serde(rename = "treeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tree_id: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MergeBranchesByThreeWayInput {
#[serde(rename = "authorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author_name: Option<String>,
#[serde(rename = "commitMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_message: Option<String>,
#[serde(rename = "conflictDetailLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_detail_level: Option<String>,
#[serde(rename = "conflictResolution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution: Option<ConflictResolution>,
#[serde(rename = "conflictResolutionStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution_strategy: Option<String>,
#[serde(rename = "destinationCommitSpecifier")]
pub destination_commit_specifier: String,
#[serde(rename = "email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "keepEmptyFolders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keep_empty_folders: Option<bool>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitSpecifier")]
pub source_commit_specifier: String,
#[serde(rename = "targetBranch")]
#[serde(skip_serializing_if = "Option::is_none")]
pub target_branch: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MergeBranchesByThreeWayOutput {
#[serde(rename = "commitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_id: Option<String>,
#[serde(rename = "treeId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub tree_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MergeHunk {
#[serde(rename = "base")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base: Option<MergeHunkDetail>,
#[serde(rename = "destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<MergeHunkDetail>,
#[serde(rename = "isConflict")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_conflict: Option<bool>,
#[serde(rename = "source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<MergeHunkDetail>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MergeHunkDetail {
#[serde(rename = "endLine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_line: Option<i64>,
#[serde(rename = "hunkContent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub hunk_content: Option<String>,
#[serde(rename = "startLine")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_line: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MergeMetadata {
#[serde(rename = "isMerged")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_merged: Option<bool>,
#[serde(rename = "mergeCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merge_commit_id: Option<String>,
#[serde(rename = "mergeOption")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merge_option: Option<String>,
#[serde(rename = "mergedBy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merged_by: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MergeOperations {
#[serde(rename = "destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
#[serde(rename = "source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MergePullRequestByFastForwardInput {
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_commit_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MergePullRequestByFastForwardOutput {
#[serde(rename = "pullRequest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request: Option<PullRequest>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MergePullRequestBySquashInput {
#[serde(rename = "authorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author_name: Option<String>,
#[serde(rename = "commitMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_message: Option<String>,
#[serde(rename = "conflictDetailLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_detail_level: Option<String>,
#[serde(rename = "conflictResolution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution: Option<ConflictResolution>,
#[serde(rename = "conflictResolutionStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution_strategy: Option<String>,
#[serde(rename = "email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "keepEmptyFolders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keep_empty_folders: Option<bool>,
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_commit_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MergePullRequestBySquashOutput {
#[serde(rename = "pullRequest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request: Option<PullRequest>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct MergePullRequestByThreeWayInput {
#[serde(rename = "authorName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author_name: Option<String>,
#[serde(rename = "commitMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_message: Option<String>,
#[serde(rename = "conflictDetailLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_detail_level: Option<String>,
#[serde(rename = "conflictResolution")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution: Option<ConflictResolution>,
#[serde(rename = "conflictResolutionStrategy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub conflict_resolution_strategy: Option<String>,
#[serde(rename = "email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "keepEmptyFolders")]
#[serde(skip_serializing_if = "Option::is_none")]
pub keep_empty_folders: Option<bool>,
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_commit_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct MergePullRequestByThreeWayOutput {
#[serde(rename = "pullRequest")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request: Option<PullRequest>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ObjectTypes {
#[serde(rename = "base")]
#[serde(skip_serializing_if = "Option::is_none")]
pub base: Option<String>,
#[serde(rename = "destination")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination: Option<String>,
#[serde(rename = "source")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct OriginApprovalRuleTemplate {
#[serde(rename = "approvalRuleTemplateId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_template_id: Option<String>,
#[serde(rename = "approvalRuleTemplateName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_template_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct OverridePullRequestApprovalRulesInput {
#[serde(rename = "overrideStatus")]
pub override_status: String,
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "revisionId")]
pub revision_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PostCommentForComparedCommitInput {
#[serde(rename = "afterCommitId")]
pub after_commit_id: String,
#[serde(rename = "beforeCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_commit_id: Option<String>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "content")]
pub content: String,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<Location>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PostCommentForComparedCommitOutput {
#[serde(rename = "afterBlobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_blob_id: Option<String>,
#[serde(rename = "afterCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_commit_id: Option<String>,
#[serde(rename = "beforeBlobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_blob_id: Option<String>,
#[serde(rename = "beforeCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_commit_id: Option<String>,
#[serde(rename = "comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<Comment>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<Location>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PostCommentForPullRequestInput {
#[serde(rename = "afterCommitId")]
pub after_commit_id: String,
#[serde(rename = "beforeCommitId")]
pub before_commit_id: String,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "content")]
pub content: String,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<Location>,
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PostCommentForPullRequestOutput {
#[serde(rename = "afterBlobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_blob_id: Option<String>,
#[serde(rename = "afterCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_commit_id: Option<String>,
#[serde(rename = "beforeBlobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_blob_id: Option<String>,
#[serde(rename = "beforeCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_commit_id: Option<String>,
#[serde(rename = "comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<Comment>,
#[serde(rename = "location")]
#[serde(skip_serializing_if = "Option::is_none")]
pub location: Option<Location>,
#[serde(rename = "pullRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PostCommentReplyInput {
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "content")]
pub content: String,
#[serde(rename = "inReplyTo")]
pub in_reply_to: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PostCommentReplyOutput {
#[serde(rename = "comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<Comment>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PullRequest {
#[serde(rename = "approvalRules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rules: Option<Vec<ApprovalRule>>,
#[serde(rename = "authorArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub author_arn: Option<String>,
#[serde(rename = "clientRequestToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub client_request_token: Option<String>,
#[serde(rename = "creationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "description")]
#[serde(skip_serializing_if = "Option::is_none")]
pub description: Option<String>,
#[serde(rename = "lastActivityDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_activity_date: Option<f64>,
#[serde(rename = "pullRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_id: Option<String>,
#[serde(rename = "pullRequestStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_status: Option<String>,
#[serde(rename = "pullRequestTargets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_targets: Option<Vec<PullRequestTarget>>,
#[serde(rename = "revisionId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub revision_id: Option<String>,
#[serde(rename = "title")]
#[serde(skip_serializing_if = "Option::is_none")]
pub title: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PullRequestCreatedEventMetadata {
#[serde(rename = "destinationCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_commit_id: Option<String>,
#[serde(rename = "mergeBase")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merge_base: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
#[serde(rename = "sourceCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_commit_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PullRequestEvent {
#[serde(rename = "actorArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub actor_arn: Option<String>,
#[serde(rename = "approvalRuleEventMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_event_metadata: Option<ApprovalRuleEventMetadata>,
#[serde(rename = "approvalRuleOverriddenEventMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_rule_overridden_event_metadata: Option<ApprovalRuleOverriddenEventMetadata>,
#[serde(rename = "approvalStateChangedEventMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub approval_state_changed_event_metadata: Option<ApprovalStateChangedEventMetadata>,
#[serde(rename = "eventDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub event_date: Option<f64>,
#[serde(rename = "pullRequestCreatedEventMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_created_event_metadata: Option<PullRequestCreatedEventMetadata>,
#[serde(rename = "pullRequestEventType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_event_type: Option<String>,
#[serde(rename = "pullRequestId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_id: Option<String>,
#[serde(rename = "pullRequestMergedStateChangedEventMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_merged_state_changed_event_metadata:
Option<PullRequestMergedStateChangedEventMetadata>,
#[serde(rename = "pullRequestSourceReferenceUpdatedEventMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_source_reference_updated_event_metadata:
Option<PullRequestSourceReferenceUpdatedEventMetadata>,
#[serde(rename = "pullRequestStatusChangedEventMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_status_changed_event_metadata: Option<PullRequestStatusChangedEventMetadata>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PullRequestMergedStateChangedEventMetadata {
#[serde(rename = "destinationReference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_reference: Option<String>,
#[serde(rename = "mergeMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merge_metadata: Option<MergeMetadata>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PullRequestSourceReferenceUpdatedEventMetadata {
#[serde(rename = "afterCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub after_commit_id: Option<String>,
#[serde(rename = "beforeCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub before_commit_id: Option<String>,
#[serde(rename = "mergeBase")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merge_base: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PullRequestStatusChangedEventMetadata {
#[serde(rename = "pullRequestStatus")]
#[serde(skip_serializing_if = "Option::is_none")]
pub pull_request_status: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PullRequestTarget {
#[serde(rename = "destinationCommit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_commit: Option<String>,
#[serde(rename = "destinationReference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_reference: Option<String>,
#[serde(rename = "mergeBase")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merge_base: Option<String>,
#[serde(rename = "mergeMetadata")]
#[serde(skip_serializing_if = "Option::is_none")]
pub merge_metadata: Option<MergeMetadata>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
#[serde(rename = "sourceCommit")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_commit: Option<String>,
#[serde(rename = "sourceReference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_reference: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutCommentReactionInput {
#[serde(rename = "commentId")]
pub comment_id: String,
#[serde(rename = "reactionValue")]
pub reaction_value: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutFileEntry {
#[serde(rename = "fileContent")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_content: Option<bytes::Bytes>,
#[serde(rename = "fileMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_mode: Option<String>,
#[serde(rename = "filePath")]
pub file_path: String,
#[serde(rename = "sourceFile")]
#[serde(skip_serializing_if = "Option::is_none")]
pub source_file: Option<SourceFileSpecifier>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutFileInput {
#[serde(rename = "branchName")]
pub branch_name: String,
#[serde(rename = "commitMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_message: Option<String>,
#[serde(rename = "email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "fileContent")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
pub file_content: bytes::Bytes,
#[serde(rename = "fileMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_mode: Option<String>,
#[serde(rename = "filePath")]
pub file_path: String,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "parentCommitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_commit_id: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutFileOutput {
#[serde(rename = "blobId")]
pub blob_id: String,
#[serde(rename = "commitId")]
pub commit_id: String,
#[serde(rename = "treeId")]
pub tree_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutRepositoryTriggersInput {
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "triggers")]
pub triggers: Vec<RepositoryTrigger>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutRepositoryTriggersOutput {
#[serde(rename = "configurationId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub configuration_id: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReactionForComment {
#[serde(rename = "reaction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reaction: Option<ReactionValueFormats>,
#[serde(rename = "reactionUsers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reaction_users: Option<Vec<String>>,
#[serde(rename = "reactionsFromDeletedUsersCount")]
#[serde(skip_serializing_if = "Option::is_none")]
pub reactions_from_deleted_users_count: Option<i64>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ReactionValueFormats {
#[serde(rename = "emoji")]
#[serde(skip_serializing_if = "Option::is_none")]
pub emoji: Option<String>,
#[serde(rename = "shortCode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub short_code: Option<String>,
#[serde(rename = "unicode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub unicode: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ReplaceContentEntry {
#[serde(rename = "content")]
#[serde(
deserialize_with = "::rusoto_core::serialization::SerdeBlob::deserialize_blob",
serialize_with = "::rusoto_core::serialization::SerdeBlob::serialize_blob",
default
)]
#[serde(skip_serializing_if = "Option::is_none")]
pub content: Option<bytes::Bytes>,
#[serde(rename = "fileMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_mode: Option<String>,
#[serde(rename = "filePath")]
pub file_path: String,
#[serde(rename = "replacementType")]
pub replacement_type: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RepositoryMetadata {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
#[serde(rename = "accountId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub account_id: Option<String>,
#[serde(rename = "cloneUrlHttp")]
#[serde(skip_serializing_if = "Option::is_none")]
pub clone_url_http: Option<String>,
#[serde(rename = "cloneUrlSsh")]
#[serde(skip_serializing_if = "Option::is_none")]
pub clone_url_ssh: Option<String>,
#[serde(rename = "creationDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date: Option<f64>,
#[serde(rename = "defaultBranch")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_branch: Option<String>,
#[serde(rename = "lastModifiedDate")]
#[serde(skip_serializing_if = "Option::is_none")]
pub last_modified_date: Option<f64>,
#[serde(rename = "repositoryDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_description: Option<String>,
#[serde(rename = "repositoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RepositoryNameIdPair {
#[serde(rename = "repositoryId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_id: Option<String>,
#[serde(rename = "repositoryName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_name: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct RepositoryTrigger {
#[serde(rename = "branches")]
#[serde(skip_serializing_if = "Option::is_none")]
pub branches: Option<Vec<String>>,
#[serde(rename = "customData")]
#[serde(skip_serializing_if = "Option::is_none")]
pub custom_data: Option<String>,
#[serde(rename = "destinationArn")]
pub destination_arn: String,
#[serde(rename = "events")]
pub events: Vec<String>,
#[serde(rename = "name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RepositoryTriggerExecutionFailure {
#[serde(rename = "failureMessage")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failure_message: Option<String>,
#[serde(rename = "trigger")]
#[serde(skip_serializing_if = "Option::is_none")]
pub trigger: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SetFileModeEntry {
#[serde(rename = "fileMode")]
pub file_mode: String,
#[serde(rename = "filePath")]
pub file_path: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct SourceFileSpecifier {
#[serde(rename = "filePath")]
pub file_path: String,
#[serde(rename = "isMove")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_move: Option<bool>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SubModule {
#[serde(rename = "absolutePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub absolute_path: Option<String>,
#[serde(rename = "commitId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub commit_id: Option<String>,
#[serde(rename = "relativePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relative_path: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct SymbolicLink {
#[serde(rename = "absolutePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub absolute_path: Option<String>,
#[serde(rename = "blobId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub blob_id: Option<String>,
#[serde(rename = "fileMode")]
#[serde(skip_serializing_if = "Option::is_none")]
pub file_mode: Option<String>,
#[serde(rename = "relativePath")]
#[serde(skip_serializing_if = "Option::is_none")]
pub relative_path: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceInput {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tags")]
pub tags: ::std::collections::HashMap<String, String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct Target {
#[serde(rename = "destinationReference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub destination_reference: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "sourceReference")]
pub source_reference: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TestRepositoryTriggersInput {
#[serde(rename = "repositoryName")]
pub repository_name: String,
#[serde(rename = "triggers")]
pub triggers: Vec<RepositoryTrigger>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TestRepositoryTriggersOutput {
#[serde(rename = "failedExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub failed_executions: Option<Vec<RepositoryTriggerExecutionFailure>>,
#[serde(rename = "successfulExecutions")]
#[serde(skip_serializing_if = "Option::is_none")]
pub successful_executions: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceInput {
#[serde(rename = "resourceArn")]
pub resource_arn: String,
#[serde(rename = "tagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApprovalRuleTemplateContentInput {
#[serde(rename = "approvalRuleTemplateName")]
pub approval_rule_template_name: String,
#[serde(rename = "existingRuleContentSha256")]
#[serde(skip_serializing_if = "Option::is_none")]
pub existing_rule_content_sha_256: Option<String>,
#[serde(rename = "newRuleContent")]
pub new_rule_content: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateApprovalRuleTemplateContentOutput {
#[serde(rename = "approvalRuleTemplate")]
pub approval_rule_template: ApprovalRuleTemplate,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApprovalRuleTemplateDescriptionInput {
#[serde(rename = "approvalRuleTemplateDescription")]
pub approval_rule_template_description: String,
#[serde(rename = "approvalRuleTemplateName")]
pub approval_rule_template_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateApprovalRuleTemplateDescriptionOutput {
#[serde(rename = "approvalRuleTemplate")]
pub approval_rule_template: ApprovalRuleTemplate,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateApprovalRuleTemplateNameInput {
#[serde(rename = "newApprovalRuleTemplateName")]
pub new_approval_rule_template_name: String,
#[serde(rename = "oldApprovalRuleTemplateName")]
pub old_approval_rule_template_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateApprovalRuleTemplateNameOutput {
#[serde(rename = "approvalRuleTemplate")]
pub approval_rule_template: ApprovalRuleTemplate,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateCommentInput {
#[serde(rename = "commentId")]
pub comment_id: String,
#[serde(rename = "content")]
pub content: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateCommentOutput {
#[serde(rename = "comment")]
#[serde(skip_serializing_if = "Option::is_none")]
pub comment: Option<Comment>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateDefaultBranchInput {
#[serde(rename = "defaultBranchName")]
pub default_branch_name: String,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdatePullRequestApprovalRuleContentInput {
#[serde(rename = "approvalRuleName")]
pub approval_rule_name: String,
#[serde(rename = "existingRuleContentSha256")]
#[serde(skip_serializing_if = "Option::is_none")]
pub existing_rule_content_sha_256: Option<String>,
#[serde(rename = "newRuleContent")]
pub new_rule_content: String,
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdatePullRequestApprovalRuleContentOutput {
#[serde(rename = "approvalRule")]
pub approval_rule: ApprovalRule,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdatePullRequestApprovalStateInput {
#[serde(rename = "approvalState")]
pub approval_state: String,
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "revisionId")]
pub revision_id: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdatePullRequestDescriptionInput {
#[serde(rename = "description")]
pub description: String,
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdatePullRequestDescriptionOutput {
#[serde(rename = "pullRequest")]
pub pull_request: PullRequest,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdatePullRequestStatusInput {
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "pullRequestStatus")]
pub pull_request_status: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdatePullRequestStatusOutput {
#[serde(rename = "pullRequest")]
pub pull_request: PullRequest,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdatePullRequestTitleInput {
#[serde(rename = "pullRequestId")]
pub pull_request_id: String,
#[serde(rename = "title")]
pub title: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdatePullRequestTitleOutput {
#[serde(rename = "pullRequest")]
pub pull_request: PullRequest,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRepositoryDescriptionInput {
#[serde(rename = "repositoryDescription")]
#[serde(skip_serializing_if = "Option::is_none")]
pub repository_description: Option<String>,
#[serde(rename = "repositoryName")]
pub repository_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateRepositoryNameInput {
#[serde(rename = "newName")]
pub new_name: String,
#[serde(rename = "oldName")]
pub old_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UserInfo {
#[serde(rename = "date")]
#[serde(skip_serializing_if = "Option::is_none")]
pub date: Option<String>,
#[serde(rename = "email")]
#[serde(skip_serializing_if = "Option::is_none")]
pub email: Option<String>,
#[serde(rename = "name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AssociateApprovalRuleTemplateWithRepositoryError {
ApprovalRuleTemplateDoesNotExist(String),
ApprovalRuleTemplateNameRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidApprovalRuleTemplateName(String),
InvalidRepositoryName(String),
MaximumRuleTemplatesAssociatedWithRepository(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl AssociateApprovalRuleTemplateWithRepositoryError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<AssociateApprovalRuleTemplateWithRepositoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleTemplateDoesNotExistException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::ApprovalRuleTemplateDoesNotExist(err.msg)),
"ApprovalRuleTemplateNameRequiredException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::ApprovalRuleTemplateNameRequired(err.msg)),
"EncryptionIntegrityChecksFailedException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::EncryptionIntegrityChecksFailed(err.msg)),
"EncryptionKeyAccessDeniedException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::EncryptionKeyAccessDenied(err.msg)),
"EncryptionKeyDisabledException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::EncryptionKeyDisabled(err.msg)),
"EncryptionKeyNotFoundException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::EncryptionKeyNotFound(err.msg)),
"EncryptionKeyUnavailableException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::EncryptionKeyUnavailable(err.msg)),
"InvalidApprovalRuleTemplateNameException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::InvalidApprovalRuleTemplateName(err.msg)),
"InvalidRepositoryNameException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::InvalidRepositoryName(err.msg)),
"MaximumRuleTemplatesAssociatedWithRepositoryException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::MaximumRuleTemplatesAssociatedWithRepository(err.msg)),
"RepositoryDoesNotExistException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::RepositoryDoesNotExist(err.msg)),
"RepositoryNameRequiredException" => return RusotoError::Service(AssociateApprovalRuleTemplateWithRepositoryError::RepositoryNameRequired(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AssociateApprovalRuleTemplateWithRepositoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AssociateApprovalRuleTemplateWithRepositoryError::ApprovalRuleTemplateDoesNotExist(ref cause) => write!(f, "{}", cause),
AssociateApprovalRuleTemplateWithRepositoryError::ApprovalRuleTemplateNameRequired(ref cause) => write!(f, "{}", cause),
AssociateApprovalRuleTemplateWithRepositoryError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
AssociateApprovalRuleTemplateWithRepositoryError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
AssociateApprovalRuleTemplateWithRepositoryError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
AssociateApprovalRuleTemplateWithRepositoryError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
AssociateApprovalRuleTemplateWithRepositoryError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
AssociateApprovalRuleTemplateWithRepositoryError::InvalidApprovalRuleTemplateName(ref cause) => write!(f, "{}", cause),
AssociateApprovalRuleTemplateWithRepositoryError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
AssociateApprovalRuleTemplateWithRepositoryError::MaximumRuleTemplatesAssociatedWithRepository(ref cause) => write!(f, "{}", cause),
AssociateApprovalRuleTemplateWithRepositoryError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
AssociateApprovalRuleTemplateWithRepositoryError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for AssociateApprovalRuleTemplateWithRepositoryError {}
#[derive(Debug, PartialEq)]
pub enum BatchAssociateApprovalRuleTemplateWithRepositoriesError {
ApprovalRuleTemplateDoesNotExist(String),
ApprovalRuleTemplateNameRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidApprovalRuleTemplateName(String),
MaximumRepositoryNamesExceeded(String),
RepositoryNamesRequired(String),
}
impl BatchAssociateApprovalRuleTemplateWithRepositoriesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchAssociateApprovalRuleTemplateWithRepositoriesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleTemplateDoesNotExistException" => return RusotoError::Service(BatchAssociateApprovalRuleTemplateWithRepositoriesError::ApprovalRuleTemplateDoesNotExist(err.msg)),
"ApprovalRuleTemplateNameRequiredException" => return RusotoError::Service(BatchAssociateApprovalRuleTemplateWithRepositoriesError::ApprovalRuleTemplateNameRequired(err.msg)),
"EncryptionIntegrityChecksFailedException" => return RusotoError::Service(BatchAssociateApprovalRuleTemplateWithRepositoriesError::EncryptionIntegrityChecksFailed(err.msg)),
"EncryptionKeyAccessDeniedException" => return RusotoError::Service(BatchAssociateApprovalRuleTemplateWithRepositoriesError::EncryptionKeyAccessDenied(err.msg)),
"EncryptionKeyDisabledException" => return RusotoError::Service(BatchAssociateApprovalRuleTemplateWithRepositoriesError::EncryptionKeyDisabled(err.msg)),
"EncryptionKeyNotFoundException" => return RusotoError::Service(BatchAssociateApprovalRuleTemplateWithRepositoriesError::EncryptionKeyNotFound(err.msg)),
"EncryptionKeyUnavailableException" => return RusotoError::Service(BatchAssociateApprovalRuleTemplateWithRepositoriesError::EncryptionKeyUnavailable(err.msg)),
"InvalidApprovalRuleTemplateNameException" => return RusotoError::Service(BatchAssociateApprovalRuleTemplateWithRepositoriesError::InvalidApprovalRuleTemplateName(err.msg)),
"MaximumRepositoryNamesExceededException" => return RusotoError::Service(BatchAssociateApprovalRuleTemplateWithRepositoriesError::MaximumRepositoryNamesExceeded(err.msg)),
"RepositoryNamesRequiredException" => return RusotoError::Service(BatchAssociateApprovalRuleTemplateWithRepositoriesError::RepositoryNamesRequired(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchAssociateApprovalRuleTemplateWithRepositoriesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchAssociateApprovalRuleTemplateWithRepositoriesError::ApprovalRuleTemplateDoesNotExist(ref cause) => write!(f, "{}", cause),
BatchAssociateApprovalRuleTemplateWithRepositoriesError::ApprovalRuleTemplateNameRequired(ref cause) => write!(f, "{}", cause),
BatchAssociateApprovalRuleTemplateWithRepositoriesError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
BatchAssociateApprovalRuleTemplateWithRepositoriesError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
BatchAssociateApprovalRuleTemplateWithRepositoriesError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
BatchAssociateApprovalRuleTemplateWithRepositoriesError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
BatchAssociateApprovalRuleTemplateWithRepositoriesError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
BatchAssociateApprovalRuleTemplateWithRepositoriesError::InvalidApprovalRuleTemplateName(ref cause) => write!(f, "{}", cause),
BatchAssociateApprovalRuleTemplateWithRepositoriesError::MaximumRepositoryNamesExceeded(ref cause) => write!(f, "{}", cause),
BatchAssociateApprovalRuleTemplateWithRepositoriesError::RepositoryNamesRequired(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for BatchAssociateApprovalRuleTemplateWithRepositoriesError {}
#[derive(Debug, PartialEq)]
pub enum BatchDescribeMergeConflictsError {
CommitDoesNotExist(String),
CommitRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidCommit(String),
InvalidConflictDetailLevel(String),
InvalidConflictResolutionStrategy(String),
InvalidContinuationToken(String),
InvalidMaxConflictFiles(String),
InvalidMaxMergeHunks(String),
InvalidMergeOption(String),
InvalidRepositoryName(String),
MaximumFileContentToLoadExceeded(String),
MaximumItemsToCompareExceeded(String),
MergeOptionRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
TipsDivergenceExceeded(String),
}
impl BatchDescribeMergeConflictsError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchDescribeMergeConflictsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitDoesNotExistException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::CommitDoesNotExist(err.msg),
)
}
"CommitRequiredException" => {
return RusotoError::Service(BatchDescribeMergeConflictsError::CommitRequired(
err.msg,
))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidCommitException" => {
return RusotoError::Service(BatchDescribeMergeConflictsError::InvalidCommit(
err.msg,
))
}
"InvalidConflictDetailLevelException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::InvalidConflictDetailLevel(err.msg),
)
}
"InvalidConflictResolutionStrategyException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::InvalidConflictResolutionStrategy(
err.msg,
),
)
}
"InvalidContinuationTokenException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::InvalidContinuationToken(err.msg),
)
}
"InvalidMaxConflictFilesException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::InvalidMaxConflictFiles(err.msg),
)
}
"InvalidMaxMergeHunksException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::InvalidMaxMergeHunks(err.msg),
)
}
"InvalidMergeOptionException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::InvalidMergeOption(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::InvalidRepositoryName(err.msg),
)
}
"MaximumFileContentToLoadExceededException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::MaximumFileContentToLoadExceeded(err.msg),
)
}
"MaximumItemsToCompareExceededException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::MaximumItemsToCompareExceeded(err.msg),
)
}
"MergeOptionRequiredException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::MergeOptionRequired(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::RepositoryNameRequired(err.msg),
)
}
"TipsDivergenceExceededException" => {
return RusotoError::Service(
BatchDescribeMergeConflictsError::TipsDivergenceExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchDescribeMergeConflictsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchDescribeMergeConflictsError::CommitDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::CommitRequired(ref cause) => write!(f, "{}", cause),
BatchDescribeMergeConflictsError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::InvalidCommit(ref cause) => write!(f, "{}", cause),
BatchDescribeMergeConflictsError::InvalidConflictDetailLevel(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::InvalidConflictResolutionStrategy(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::InvalidContinuationToken(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::InvalidMaxConflictFiles(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::InvalidMaxMergeHunks(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::InvalidMergeOption(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::MaximumFileContentToLoadExceeded(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::MaximumItemsToCompareExceeded(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::MergeOptionRequired(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
BatchDescribeMergeConflictsError::TipsDivergenceExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for BatchDescribeMergeConflictsError {}
#[derive(Debug, PartialEq)]
pub enum BatchDisassociateApprovalRuleTemplateFromRepositoriesError {
ApprovalRuleTemplateDoesNotExist(String),
ApprovalRuleTemplateNameRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidApprovalRuleTemplateName(String),
MaximumRepositoryNamesExceeded(String),
RepositoryNamesRequired(String),
}
impl BatchDisassociateApprovalRuleTemplateFromRepositoriesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<BatchDisassociateApprovalRuleTemplateFromRepositoriesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleTemplateDoesNotExistException" => return RusotoError::Service(BatchDisassociateApprovalRuleTemplateFromRepositoriesError::ApprovalRuleTemplateDoesNotExist(err.msg)),
"ApprovalRuleTemplateNameRequiredException" => return RusotoError::Service(BatchDisassociateApprovalRuleTemplateFromRepositoriesError::ApprovalRuleTemplateNameRequired(err.msg)),
"EncryptionIntegrityChecksFailedException" => return RusotoError::Service(BatchDisassociateApprovalRuleTemplateFromRepositoriesError::EncryptionIntegrityChecksFailed(err.msg)),
"EncryptionKeyAccessDeniedException" => return RusotoError::Service(BatchDisassociateApprovalRuleTemplateFromRepositoriesError::EncryptionKeyAccessDenied(err.msg)),
"EncryptionKeyDisabledException" => return RusotoError::Service(BatchDisassociateApprovalRuleTemplateFromRepositoriesError::EncryptionKeyDisabled(err.msg)),
"EncryptionKeyNotFoundException" => return RusotoError::Service(BatchDisassociateApprovalRuleTemplateFromRepositoriesError::EncryptionKeyNotFound(err.msg)),
"EncryptionKeyUnavailableException" => return RusotoError::Service(BatchDisassociateApprovalRuleTemplateFromRepositoriesError::EncryptionKeyUnavailable(err.msg)),
"InvalidApprovalRuleTemplateNameException" => return RusotoError::Service(BatchDisassociateApprovalRuleTemplateFromRepositoriesError::InvalidApprovalRuleTemplateName(err.msg)),
"MaximumRepositoryNamesExceededException" => return RusotoError::Service(BatchDisassociateApprovalRuleTemplateFromRepositoriesError::MaximumRepositoryNamesExceeded(err.msg)),
"RepositoryNamesRequiredException" => return RusotoError::Service(BatchDisassociateApprovalRuleTemplateFromRepositoriesError::RepositoryNamesRequired(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchDisassociateApprovalRuleTemplateFromRepositoriesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchDisassociateApprovalRuleTemplateFromRepositoriesError::ApprovalRuleTemplateDoesNotExist(ref cause) => write!(f, "{}", cause),
BatchDisassociateApprovalRuleTemplateFromRepositoriesError::ApprovalRuleTemplateNameRequired(ref cause) => write!(f, "{}", cause),
BatchDisassociateApprovalRuleTemplateFromRepositoriesError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
BatchDisassociateApprovalRuleTemplateFromRepositoriesError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
BatchDisassociateApprovalRuleTemplateFromRepositoriesError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
BatchDisassociateApprovalRuleTemplateFromRepositoriesError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
BatchDisassociateApprovalRuleTemplateFromRepositoriesError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
BatchDisassociateApprovalRuleTemplateFromRepositoriesError::InvalidApprovalRuleTemplateName(ref cause) => write!(f, "{}", cause),
BatchDisassociateApprovalRuleTemplateFromRepositoriesError::MaximumRepositoryNamesExceeded(ref cause) => write!(f, "{}", cause),
BatchDisassociateApprovalRuleTemplateFromRepositoriesError::RepositoryNamesRequired(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for BatchDisassociateApprovalRuleTemplateFromRepositoriesError {}
#[derive(Debug, PartialEq)]
pub enum BatchGetCommitsError {
CommitIdsLimitExceeded(String),
CommitIdsListRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl BatchGetCommitsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchGetCommitsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitIdsLimitExceededException" => {
return RusotoError::Service(BatchGetCommitsError::CommitIdsLimitExceeded(
err.msg,
))
}
"CommitIdsListRequiredException" => {
return RusotoError::Service(BatchGetCommitsError::CommitIdsListRequired(
err.msg,
))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
BatchGetCommitsError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(BatchGetCommitsError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(BatchGetCommitsError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(BatchGetCommitsError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(BatchGetCommitsError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(BatchGetCommitsError::InvalidRepositoryName(
err.msg,
))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(BatchGetCommitsError::RepositoryDoesNotExist(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(BatchGetCommitsError::RepositoryNameRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetCommitsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetCommitsError::CommitIdsLimitExceeded(ref cause) => write!(f, "{}", cause),
BatchGetCommitsError::CommitIdsListRequired(ref cause) => write!(f, "{}", cause),
BatchGetCommitsError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
BatchGetCommitsError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
BatchGetCommitsError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
BatchGetCommitsError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
BatchGetCommitsError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
BatchGetCommitsError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
BatchGetCommitsError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
BatchGetCommitsError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchGetCommitsError {}
#[derive(Debug, PartialEq)]
pub enum BatchGetRepositoriesError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidRepositoryName(String),
MaximumRepositoryNamesExceeded(String),
RepositoryNamesRequired(String),
}
impl BatchGetRepositoriesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchGetRepositoriesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
BatchGetRepositoriesError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
BatchGetRepositoriesError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(BatchGetRepositoriesError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(BatchGetRepositoriesError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
BatchGetRepositoriesError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(BatchGetRepositoriesError::InvalidRepositoryName(
err.msg,
))
}
"MaximumRepositoryNamesExceededException" => {
return RusotoError::Service(
BatchGetRepositoriesError::MaximumRepositoryNamesExceeded(err.msg),
)
}
"RepositoryNamesRequiredException" => {
return RusotoError::Service(
BatchGetRepositoriesError::RepositoryNamesRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchGetRepositoriesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchGetRepositoriesError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
BatchGetRepositoriesError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
BatchGetRepositoriesError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
BatchGetRepositoriesError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
BatchGetRepositoriesError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
BatchGetRepositoriesError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
BatchGetRepositoriesError::MaximumRepositoryNamesExceeded(ref cause) => {
write!(f, "{}", cause)
}
BatchGetRepositoriesError::RepositoryNamesRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchGetRepositoriesError {}
#[derive(Debug, PartialEq)]
pub enum CreateApprovalRuleTemplateError {
ApprovalRuleTemplateContentRequired(String),
ApprovalRuleTemplateNameAlreadyExists(String),
ApprovalRuleTemplateNameRequired(String),
InvalidApprovalRuleTemplateContent(String),
InvalidApprovalRuleTemplateDescription(String),
InvalidApprovalRuleTemplateName(String),
NumberOfRuleTemplatesExceeded(String),
}
impl CreateApprovalRuleTemplateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateApprovalRuleTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleTemplateContentRequiredException" => {
return RusotoError::Service(
CreateApprovalRuleTemplateError::ApprovalRuleTemplateContentRequired(
err.msg,
),
)
}
"ApprovalRuleTemplateNameAlreadyExistsException" => {
return RusotoError::Service(
CreateApprovalRuleTemplateError::ApprovalRuleTemplateNameAlreadyExists(
err.msg,
),
)
}
"ApprovalRuleTemplateNameRequiredException" => {
return RusotoError::Service(
CreateApprovalRuleTemplateError::ApprovalRuleTemplateNameRequired(err.msg),
)
}
"InvalidApprovalRuleTemplateContentException" => {
return RusotoError::Service(
CreateApprovalRuleTemplateError::InvalidApprovalRuleTemplateContent(
err.msg,
),
)
}
"InvalidApprovalRuleTemplateDescriptionException" => {
return RusotoError::Service(
CreateApprovalRuleTemplateError::InvalidApprovalRuleTemplateDescription(
err.msg,
),
)
}
"InvalidApprovalRuleTemplateNameException" => {
return RusotoError::Service(
CreateApprovalRuleTemplateError::InvalidApprovalRuleTemplateName(err.msg),
)
}
"NumberOfRuleTemplatesExceededException" => {
return RusotoError::Service(
CreateApprovalRuleTemplateError::NumberOfRuleTemplatesExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateApprovalRuleTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateApprovalRuleTemplateError::ApprovalRuleTemplateContentRequired(ref cause) => {
write!(f, "{}", cause)
}
CreateApprovalRuleTemplateError::ApprovalRuleTemplateNameAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreateApprovalRuleTemplateError::ApprovalRuleTemplateNameRequired(ref cause) => {
write!(f, "{}", cause)
}
CreateApprovalRuleTemplateError::InvalidApprovalRuleTemplateContent(ref cause) => {
write!(f, "{}", cause)
}
CreateApprovalRuleTemplateError::InvalidApprovalRuleTemplateDescription(ref cause) => {
write!(f, "{}", cause)
}
CreateApprovalRuleTemplateError::InvalidApprovalRuleTemplateName(ref cause) => {
write!(f, "{}", cause)
}
CreateApprovalRuleTemplateError::NumberOfRuleTemplatesExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateApprovalRuleTemplateError {}
#[derive(Debug, PartialEq)]
pub enum CreateBranchError {
BranchNameExists(String),
BranchNameRequired(String),
CommitDoesNotExist(String),
CommitIdRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidBranchName(String),
InvalidCommitId(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl CreateBranchError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateBranchError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BranchNameExistsException" => {
return RusotoError::Service(CreateBranchError::BranchNameExists(err.msg))
}
"BranchNameRequiredException" => {
return RusotoError::Service(CreateBranchError::BranchNameRequired(err.msg))
}
"CommitDoesNotExistException" => {
return RusotoError::Service(CreateBranchError::CommitDoesNotExist(err.msg))
}
"CommitIdRequiredException" => {
return RusotoError::Service(CreateBranchError::CommitIdRequired(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
CreateBranchError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(CreateBranchError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(CreateBranchError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(CreateBranchError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(CreateBranchError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidBranchNameException" => {
return RusotoError::Service(CreateBranchError::InvalidBranchName(err.msg))
}
"InvalidCommitIdException" => {
return RusotoError::Service(CreateBranchError::InvalidCommitId(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(CreateBranchError::InvalidRepositoryName(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(CreateBranchError::RepositoryDoesNotExist(err.msg))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(CreateBranchError::RepositoryNameRequired(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::BranchNameExists(ref cause) => write!(f, "{}", cause),
CreateBranchError::BranchNameRequired(ref cause) => write!(f, "{}", cause),
CreateBranchError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateBranchError::CommitIdRequired(ref cause) => write!(f, "{}", cause),
CreateBranchError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
CreateBranchError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
CreateBranchError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
CreateBranchError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
CreateBranchError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
CreateBranchError::InvalidBranchName(ref cause) => write!(f, "{}", cause),
CreateBranchError::InvalidCommitId(ref cause) => write!(f, "{}", cause),
CreateBranchError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
CreateBranchError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateBranchError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateBranchError {}
#[derive(Debug, PartialEq)]
pub enum CreateCommitError {
BranchDoesNotExist(String),
BranchNameIsTagName(String),
BranchNameRequired(String),
CommitMessageLengthExceeded(String),
DirectoryNameConflictsWithFileName(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FileContentAndSourceFileSpecified(String),
FileContentSizeLimitExceeded(String),
FileDoesNotExist(String),
FileEntryRequired(String),
FileModeRequired(String),
FileNameConflictsWithDirectoryName(String),
FilePathConflictsWithSubmodulePath(String),
FolderContentSizeLimitExceeded(String),
InvalidBranchName(String),
InvalidDeletionParameter(String),
InvalidEmail(String),
InvalidFileMode(String),
InvalidParentCommitId(String),
InvalidPath(String),
InvalidRepositoryName(String),
MaximumFileEntriesExceeded(String),
NameLengthExceeded(String),
NoChange(String),
ParentCommitDoesNotExist(String),
ParentCommitIdOutdated(String),
ParentCommitIdRequired(String),
PathRequired(String),
PutFileEntryConflict(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
RestrictedSourceFile(String),
SamePathRequest(String),
SourceFileOrContentRequired(String),
}
impl CreateCommitError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateCommitError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BranchDoesNotExistException" => {
return RusotoError::Service(CreateCommitError::BranchDoesNotExist(err.msg))
}
"BranchNameIsTagNameException" => {
return RusotoError::Service(CreateCommitError::BranchNameIsTagName(err.msg))
}
"BranchNameRequiredException" => {
return RusotoError::Service(CreateCommitError::BranchNameRequired(err.msg))
}
"CommitMessageLengthExceededException" => {
return RusotoError::Service(CreateCommitError::CommitMessageLengthExceeded(
err.msg,
))
}
"DirectoryNameConflictsWithFileNameException" => {
return RusotoError::Service(
CreateCommitError::DirectoryNameConflictsWithFileName(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
CreateCommitError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(CreateCommitError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(CreateCommitError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(CreateCommitError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(CreateCommitError::EncryptionKeyUnavailable(
err.msg,
))
}
"FileContentAndSourceFileSpecifiedException" => {
return RusotoError::Service(
CreateCommitError::FileContentAndSourceFileSpecified(err.msg),
)
}
"FileContentSizeLimitExceededException" => {
return RusotoError::Service(CreateCommitError::FileContentSizeLimitExceeded(
err.msg,
))
}
"FileDoesNotExistException" => {
return RusotoError::Service(CreateCommitError::FileDoesNotExist(err.msg))
}
"FileEntryRequiredException" => {
return RusotoError::Service(CreateCommitError::FileEntryRequired(err.msg))
}
"FileModeRequiredException" => {
return RusotoError::Service(CreateCommitError::FileModeRequired(err.msg))
}
"FileNameConflictsWithDirectoryNameException" => {
return RusotoError::Service(
CreateCommitError::FileNameConflictsWithDirectoryName(err.msg),
)
}
"FilePathConflictsWithSubmodulePathException" => {
return RusotoError::Service(
CreateCommitError::FilePathConflictsWithSubmodulePath(err.msg),
)
}
"FolderContentSizeLimitExceededException" => {
return RusotoError::Service(CreateCommitError::FolderContentSizeLimitExceeded(
err.msg,
))
}
"InvalidBranchNameException" => {
return RusotoError::Service(CreateCommitError::InvalidBranchName(err.msg))
}
"InvalidDeletionParameterException" => {
return RusotoError::Service(CreateCommitError::InvalidDeletionParameter(
err.msg,
))
}
"InvalidEmailException" => {
return RusotoError::Service(CreateCommitError::InvalidEmail(err.msg))
}
"InvalidFileModeException" => {
return RusotoError::Service(CreateCommitError::InvalidFileMode(err.msg))
}
"InvalidParentCommitIdException" => {
return RusotoError::Service(CreateCommitError::InvalidParentCommitId(err.msg))
}
"InvalidPathException" => {
return RusotoError::Service(CreateCommitError::InvalidPath(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(CreateCommitError::InvalidRepositoryName(err.msg))
}
"MaximumFileEntriesExceededException" => {
return RusotoError::Service(CreateCommitError::MaximumFileEntriesExceeded(
err.msg,
))
}
"NameLengthExceededException" => {
return RusotoError::Service(CreateCommitError::NameLengthExceeded(err.msg))
}
"NoChangeException" => {
return RusotoError::Service(CreateCommitError::NoChange(err.msg))
}
"ParentCommitDoesNotExistException" => {
return RusotoError::Service(CreateCommitError::ParentCommitDoesNotExist(
err.msg,
))
}
"ParentCommitIdOutdatedException" => {
return RusotoError::Service(CreateCommitError::ParentCommitIdOutdated(err.msg))
}
"ParentCommitIdRequiredException" => {
return RusotoError::Service(CreateCommitError::ParentCommitIdRequired(err.msg))
}
"PathRequiredException" => {
return RusotoError::Service(CreateCommitError::PathRequired(err.msg))
}
"PutFileEntryConflictException" => {
return RusotoError::Service(CreateCommitError::PutFileEntryConflict(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(CreateCommitError::RepositoryDoesNotExist(err.msg))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(CreateCommitError::RepositoryNameRequired(err.msg))
}
"RestrictedSourceFileException" => {
return RusotoError::Service(CreateCommitError::RestrictedSourceFile(err.msg))
}
"SamePathRequestException" => {
return RusotoError::Service(CreateCommitError::SamePathRequest(err.msg))
}
"SourceFileOrContentRequiredException" => {
return RusotoError::Service(CreateCommitError::SourceFileOrContentRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateCommitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateCommitError::BranchDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateCommitError::BranchNameIsTagName(ref cause) => write!(f, "{}", cause),
CreateCommitError::BranchNameRequired(ref cause) => write!(f, "{}", cause),
CreateCommitError::CommitMessageLengthExceeded(ref cause) => write!(f, "{}", cause),
CreateCommitError::DirectoryNameConflictsWithFileName(ref cause) => {
write!(f, "{}", cause)
}
CreateCommitError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
CreateCommitError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
CreateCommitError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
CreateCommitError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
CreateCommitError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
CreateCommitError::FileContentAndSourceFileSpecified(ref cause) => {
write!(f, "{}", cause)
}
CreateCommitError::FileContentSizeLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateCommitError::FileDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateCommitError::FileEntryRequired(ref cause) => write!(f, "{}", cause),
CreateCommitError::FileModeRequired(ref cause) => write!(f, "{}", cause),
CreateCommitError::FileNameConflictsWithDirectoryName(ref cause) => {
write!(f, "{}", cause)
}
CreateCommitError::FilePathConflictsWithSubmodulePath(ref cause) => {
write!(f, "{}", cause)
}
CreateCommitError::FolderContentSizeLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateCommitError::InvalidBranchName(ref cause) => write!(f, "{}", cause),
CreateCommitError::InvalidDeletionParameter(ref cause) => write!(f, "{}", cause),
CreateCommitError::InvalidEmail(ref cause) => write!(f, "{}", cause),
CreateCommitError::InvalidFileMode(ref cause) => write!(f, "{}", cause),
CreateCommitError::InvalidParentCommitId(ref cause) => write!(f, "{}", cause),
CreateCommitError::InvalidPath(ref cause) => write!(f, "{}", cause),
CreateCommitError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
CreateCommitError::MaximumFileEntriesExceeded(ref cause) => write!(f, "{}", cause),
CreateCommitError::NameLengthExceeded(ref cause) => write!(f, "{}", cause),
CreateCommitError::NoChange(ref cause) => write!(f, "{}", cause),
CreateCommitError::ParentCommitDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateCommitError::ParentCommitIdOutdated(ref cause) => write!(f, "{}", cause),
CreateCommitError::ParentCommitIdRequired(ref cause) => write!(f, "{}", cause),
CreateCommitError::PathRequired(ref cause) => write!(f, "{}", cause),
CreateCommitError::PutFileEntryConflict(ref cause) => write!(f, "{}", cause),
CreateCommitError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
CreateCommitError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
CreateCommitError::RestrictedSourceFile(ref cause) => write!(f, "{}", cause),
CreateCommitError::SamePathRequest(ref cause) => write!(f, "{}", cause),
CreateCommitError::SourceFileOrContentRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateCommitError {}
#[derive(Debug, PartialEq)]
pub enum CreatePullRequestError {
ClientRequestTokenRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
IdempotencyParameterMismatch(String),
InvalidClientRequestToken(String),
InvalidDescription(String),
InvalidReferenceName(String),
InvalidRepositoryName(String),
InvalidTarget(String),
InvalidTargets(String),
InvalidTitle(String),
MaximumOpenPullRequestsExceeded(String),
MultipleRepositoriesInPullRequest(String),
ReferenceDoesNotExist(String),
ReferenceNameRequired(String),
ReferenceTypeNotSupported(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
SourceAndDestinationAreSame(String),
TargetRequired(String),
TargetsRequired(String),
TitleRequired(String),
}
impl CreatePullRequestError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreatePullRequestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientRequestTokenRequiredException" => {
return RusotoError::Service(
CreatePullRequestError::ClientRequestTokenRequired(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
CreatePullRequestError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(CreatePullRequestError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(CreatePullRequestError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(CreatePullRequestError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(CreatePullRequestError::EncryptionKeyUnavailable(
err.msg,
))
}
"IdempotencyParameterMismatchException" => {
return RusotoError::Service(
CreatePullRequestError::IdempotencyParameterMismatch(err.msg),
)
}
"InvalidClientRequestTokenException" => {
return RusotoError::Service(CreatePullRequestError::InvalidClientRequestToken(
err.msg,
))
}
"InvalidDescriptionException" => {
return RusotoError::Service(CreatePullRequestError::InvalidDescription(
err.msg,
))
}
"InvalidReferenceNameException" => {
return RusotoError::Service(CreatePullRequestError::InvalidReferenceName(
err.msg,
))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(CreatePullRequestError::InvalidRepositoryName(
err.msg,
))
}
"InvalidTargetException" => {
return RusotoError::Service(CreatePullRequestError::InvalidTarget(err.msg))
}
"InvalidTargetsException" => {
return RusotoError::Service(CreatePullRequestError::InvalidTargets(err.msg))
}
"InvalidTitleException" => {
return RusotoError::Service(CreatePullRequestError::InvalidTitle(err.msg))
}
"MaximumOpenPullRequestsExceededException" => {
return RusotoError::Service(
CreatePullRequestError::MaximumOpenPullRequestsExceeded(err.msg),
)
}
"MultipleRepositoriesInPullRequestException" => {
return RusotoError::Service(
CreatePullRequestError::MultipleRepositoriesInPullRequest(err.msg),
)
}
"ReferenceDoesNotExistException" => {
return RusotoError::Service(CreatePullRequestError::ReferenceDoesNotExist(
err.msg,
))
}
"ReferenceNameRequiredException" => {
return RusotoError::Service(CreatePullRequestError::ReferenceNameRequired(
err.msg,
))
}
"ReferenceTypeNotSupportedException" => {
return RusotoError::Service(CreatePullRequestError::ReferenceTypeNotSupported(
err.msg,
))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(CreatePullRequestError::RepositoryDoesNotExist(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(CreatePullRequestError::RepositoryNameRequired(
err.msg,
))
}
"SourceAndDestinationAreSameException" => {
return RusotoError::Service(
CreatePullRequestError::SourceAndDestinationAreSame(err.msg),
)
}
"TargetRequiredException" => {
return RusotoError::Service(CreatePullRequestError::TargetRequired(err.msg))
}
"TargetsRequiredException" => {
return RusotoError::Service(CreatePullRequestError::TargetsRequired(err.msg))
}
"TitleRequiredException" => {
return RusotoError::Service(CreatePullRequestError::TitleRequired(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePullRequestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePullRequestError::ClientRequestTokenRequired(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::IdempotencyParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestError::InvalidClientRequestToken(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::InvalidDescription(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::InvalidReferenceName(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::InvalidTarget(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::InvalidTargets(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::InvalidTitle(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::MaximumOpenPullRequestsExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestError::MultipleRepositoriesInPullRequest(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestError::ReferenceDoesNotExist(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::ReferenceNameRequired(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::ReferenceTypeNotSupported(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::SourceAndDestinationAreSame(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestError::TargetRequired(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::TargetsRequired(ref cause) => write!(f, "{}", cause),
CreatePullRequestError::TitleRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreatePullRequestError {}
#[derive(Debug, PartialEq)]
pub enum CreatePullRequestApprovalRuleError {
ApprovalRuleContentRequired(String),
ApprovalRuleNameAlreadyExists(String),
ApprovalRuleNameRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidApprovalRuleContent(String),
InvalidApprovalRuleName(String),
InvalidPullRequestId(String),
NumberOfRulesExceeded(String),
PullRequestAlreadyClosed(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
}
impl CreatePullRequestApprovalRuleError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreatePullRequestApprovalRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleContentRequiredException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::ApprovalRuleContentRequired(err.msg),
)
}
"ApprovalRuleNameAlreadyExistsException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::ApprovalRuleNameAlreadyExists(err.msg),
)
}
"ApprovalRuleNameRequiredException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::ApprovalRuleNameRequired(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::EncryptionIntegrityChecksFailed(
err.msg,
),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidApprovalRuleContentException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::InvalidApprovalRuleContent(err.msg),
)
}
"InvalidApprovalRuleNameException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::InvalidApprovalRuleName(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::InvalidPullRequestId(err.msg),
)
}
"NumberOfRulesExceededException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::NumberOfRulesExceeded(err.msg),
)
}
"PullRequestAlreadyClosedException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::PullRequestAlreadyClosed(err.msg),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
CreatePullRequestApprovalRuleError::PullRequestIdRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreatePullRequestApprovalRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreatePullRequestApprovalRuleError::ApprovalRuleContentRequired(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::ApprovalRuleNameAlreadyExists(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::ApprovalRuleNameRequired(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::InvalidApprovalRuleContent(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::InvalidApprovalRuleName(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::NumberOfRulesExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::PullRequestAlreadyClosed(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
CreatePullRequestApprovalRuleError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreatePullRequestApprovalRuleError {}
#[derive(Debug, PartialEq)]
pub enum CreateRepositoryError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidRepositoryDescription(String),
InvalidRepositoryName(String),
InvalidSystemTagUsage(String),
InvalidTagsMap(String),
RepositoryLimitExceeded(String),
RepositoryNameExists(String),
RepositoryNameRequired(String),
TagPolicy(String),
TooManyTags(String),
}
impl CreateRepositoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateRepositoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
CreateRepositoryError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(CreateRepositoryError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(CreateRepositoryError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(CreateRepositoryError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(CreateRepositoryError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidRepositoryDescriptionException" => {
return RusotoError::Service(
CreateRepositoryError::InvalidRepositoryDescription(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(CreateRepositoryError::InvalidRepositoryName(
err.msg,
))
}
"InvalidSystemTagUsageException" => {
return RusotoError::Service(CreateRepositoryError::InvalidSystemTagUsage(
err.msg,
))
}
"InvalidTagsMapException" => {
return RusotoError::Service(CreateRepositoryError::InvalidTagsMap(err.msg))
}
"RepositoryLimitExceededException" => {
return RusotoError::Service(CreateRepositoryError::RepositoryLimitExceeded(
err.msg,
))
}
"RepositoryNameExistsException" => {
return RusotoError::Service(CreateRepositoryError::RepositoryNameExists(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(CreateRepositoryError::RepositoryNameRequired(
err.msg,
))
}
"TagPolicyException" => {
return RusotoError::Service(CreateRepositoryError::TagPolicy(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(CreateRepositoryError::TooManyTags(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateRepositoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateRepositoryError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
CreateRepositoryError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
CreateRepositoryError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
CreateRepositoryError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
CreateRepositoryError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
CreateRepositoryError::InvalidRepositoryDescription(ref cause) => {
write!(f, "{}", cause)
}
CreateRepositoryError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
CreateRepositoryError::InvalidSystemTagUsage(ref cause) => write!(f, "{}", cause),
CreateRepositoryError::InvalidTagsMap(ref cause) => write!(f, "{}", cause),
CreateRepositoryError::RepositoryLimitExceeded(ref cause) => write!(f, "{}", cause),
CreateRepositoryError::RepositoryNameExists(ref cause) => write!(f, "{}", cause),
CreateRepositoryError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
CreateRepositoryError::TagPolicy(ref cause) => write!(f, "{}", cause),
CreateRepositoryError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateRepositoryError {}
#[derive(Debug, PartialEq)]
pub enum CreateUnreferencedMergeCommitError {
CommitDoesNotExist(String),
CommitMessageLengthExceeded(String),
CommitRequired(String),
ConcurrentReferenceUpdate(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FileContentSizeLimitExceeded(String),
FileModeRequired(String),
FolderContentSizeLimitExceeded(String),
InvalidCommit(String),
InvalidConflictDetailLevel(String),
InvalidConflictResolution(String),
InvalidConflictResolutionStrategy(String),
InvalidEmail(String),
InvalidFileMode(String),
InvalidMergeOption(String),
InvalidPath(String),
InvalidReplacementContent(String),
InvalidReplacementType(String),
InvalidRepositoryName(String),
ManualMergeRequired(String),
MaximumConflictResolutionEntriesExceeded(String),
MaximumFileContentToLoadExceeded(String),
MaximumItemsToCompareExceeded(String),
MergeOptionRequired(String),
MultipleConflictResolutionEntries(String),
NameLengthExceeded(String),
PathRequired(String),
ReplacementContentRequired(String),
ReplacementTypeRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
TipsDivergenceExceeded(String),
}
impl CreateUnreferencedMergeCommitError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<CreateUnreferencedMergeCommitError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitDoesNotExistException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::CommitDoesNotExist(err.msg),
)
}
"CommitMessageLengthExceededException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::CommitMessageLengthExceeded(err.msg),
)
}
"CommitRequiredException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::CommitRequired(err.msg),
)
}
"ConcurrentReferenceUpdateException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::ConcurrentReferenceUpdate(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::EncryptionIntegrityChecksFailed(
err.msg,
),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::EncryptionKeyUnavailable(err.msg),
)
}
"FileContentSizeLimitExceededException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::FileContentSizeLimitExceeded(err.msg),
)
}
"FileModeRequiredException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::FileModeRequired(err.msg),
)
}
"FolderContentSizeLimitExceededException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::FolderContentSizeLimitExceeded(err.msg),
)
}
"InvalidCommitException" => {
return RusotoError::Service(CreateUnreferencedMergeCommitError::InvalidCommit(
err.msg,
))
}
"InvalidConflictDetailLevelException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::InvalidConflictDetailLevel(err.msg),
)
}
"InvalidConflictResolutionException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::InvalidConflictResolution(err.msg),
)
}
"InvalidConflictResolutionStrategyException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::InvalidConflictResolutionStrategy(
err.msg,
),
)
}
"InvalidEmailException" => {
return RusotoError::Service(CreateUnreferencedMergeCommitError::InvalidEmail(
err.msg,
))
}
"InvalidFileModeException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::InvalidFileMode(err.msg),
)
}
"InvalidMergeOptionException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::InvalidMergeOption(err.msg),
)
}
"InvalidPathException" => {
return RusotoError::Service(CreateUnreferencedMergeCommitError::InvalidPath(
err.msg,
))
}
"InvalidReplacementContentException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::InvalidReplacementContent(err.msg),
)
}
"InvalidReplacementTypeException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::InvalidReplacementType(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::InvalidRepositoryName(err.msg),
)
}
"ManualMergeRequiredException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::ManualMergeRequired(err.msg),
)
}
"MaximumConflictResolutionEntriesExceededException" => return RusotoError::Service(
CreateUnreferencedMergeCommitError::MaximumConflictResolutionEntriesExceeded(
err.msg,
),
),
"MaximumFileContentToLoadExceededException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::MaximumFileContentToLoadExceeded(
err.msg,
),
)
}
"MaximumItemsToCompareExceededException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::MaximumItemsToCompareExceeded(err.msg),
)
}
"MergeOptionRequiredException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::MergeOptionRequired(err.msg),
)
}
"MultipleConflictResolutionEntriesException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::MultipleConflictResolutionEntries(
err.msg,
),
)
}
"NameLengthExceededException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::NameLengthExceeded(err.msg),
)
}
"PathRequiredException" => {
return RusotoError::Service(CreateUnreferencedMergeCommitError::PathRequired(
err.msg,
))
}
"ReplacementContentRequiredException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::ReplacementContentRequired(err.msg),
)
}
"ReplacementTypeRequiredException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::ReplacementTypeRequired(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::RepositoryNameRequired(err.msg),
)
}
"TipsDivergenceExceededException" => {
return RusotoError::Service(
CreateUnreferencedMergeCommitError::TipsDivergenceExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateUnreferencedMergeCommitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateUnreferencedMergeCommitError::CommitDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::CommitMessageLengthExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::CommitRequired(ref cause) => write!(f, "{}", cause),
CreateUnreferencedMergeCommitError::ConcurrentReferenceUpdate(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::FileContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::FileModeRequired(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::FolderContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::InvalidCommit(ref cause) => write!(f, "{}", cause),
CreateUnreferencedMergeCommitError::InvalidConflictDetailLevel(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::InvalidConflictResolution(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::InvalidConflictResolutionStrategy(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::InvalidEmail(ref cause) => write!(f, "{}", cause),
CreateUnreferencedMergeCommitError::InvalidFileMode(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::InvalidMergeOption(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::InvalidPath(ref cause) => write!(f, "{}", cause),
CreateUnreferencedMergeCommitError::InvalidReplacementContent(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::InvalidReplacementType(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::ManualMergeRequired(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::MaximumConflictResolutionEntriesExceeded(
ref cause,
) => write!(f, "{}", cause),
CreateUnreferencedMergeCommitError::MaximumFileContentToLoadExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::MaximumItemsToCompareExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::MergeOptionRequired(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::MultipleConflictResolutionEntries(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::NameLengthExceeded(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::PathRequired(ref cause) => write!(f, "{}", cause),
CreateUnreferencedMergeCommitError::ReplacementContentRequired(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::ReplacementTypeRequired(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
CreateUnreferencedMergeCommitError::TipsDivergenceExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for CreateUnreferencedMergeCommitError {}
#[derive(Debug, PartialEq)]
pub enum DeleteApprovalRuleTemplateError {
ApprovalRuleTemplateInUse(String),
ApprovalRuleTemplateNameRequired(String),
InvalidApprovalRuleTemplateName(String),
}
impl DeleteApprovalRuleTemplateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeleteApprovalRuleTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleTemplateInUseException" => {
return RusotoError::Service(
DeleteApprovalRuleTemplateError::ApprovalRuleTemplateInUse(err.msg),
)
}
"ApprovalRuleTemplateNameRequiredException" => {
return RusotoError::Service(
DeleteApprovalRuleTemplateError::ApprovalRuleTemplateNameRequired(err.msg),
)
}
"InvalidApprovalRuleTemplateNameException" => {
return RusotoError::Service(
DeleteApprovalRuleTemplateError::InvalidApprovalRuleTemplateName(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteApprovalRuleTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteApprovalRuleTemplateError::ApprovalRuleTemplateInUse(ref cause) => {
write!(f, "{}", cause)
}
DeleteApprovalRuleTemplateError::ApprovalRuleTemplateNameRequired(ref cause) => {
write!(f, "{}", cause)
}
DeleteApprovalRuleTemplateError::InvalidApprovalRuleTemplateName(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeleteApprovalRuleTemplateError {}
#[derive(Debug, PartialEq)]
pub enum DeleteBranchError {
BranchNameRequired(String),
DefaultBranchCannotBeDeleted(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidBranchName(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl DeleteBranchError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteBranchError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BranchNameRequiredException" => {
return RusotoError::Service(DeleteBranchError::BranchNameRequired(err.msg))
}
"DefaultBranchCannotBeDeletedException" => {
return RusotoError::Service(DeleteBranchError::DefaultBranchCannotBeDeleted(
err.msg,
))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
DeleteBranchError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(DeleteBranchError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(DeleteBranchError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(DeleteBranchError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(DeleteBranchError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidBranchNameException" => {
return RusotoError::Service(DeleteBranchError::InvalidBranchName(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(DeleteBranchError::InvalidRepositoryName(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(DeleteBranchError::RepositoryDoesNotExist(err.msg))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(DeleteBranchError::RepositoryNameRequired(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::BranchNameRequired(ref cause) => write!(f, "{}", cause),
DeleteBranchError::DefaultBranchCannotBeDeleted(ref cause) => write!(f, "{}", cause),
DeleteBranchError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
DeleteBranchError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
DeleteBranchError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
DeleteBranchError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
DeleteBranchError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
DeleteBranchError::InvalidBranchName(ref cause) => write!(f, "{}", cause),
DeleteBranchError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
DeleteBranchError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
DeleteBranchError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteBranchError {}
#[derive(Debug, PartialEq)]
pub enum DeleteCommentContentError {
CommentDeleted(String),
CommentDoesNotExist(String),
CommentIdRequired(String),
InvalidCommentId(String),
}
impl DeleteCommentContentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteCommentContentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommentDeletedException" => {
return RusotoError::Service(DeleteCommentContentError::CommentDeleted(err.msg))
}
"CommentDoesNotExistException" => {
return RusotoError::Service(DeleteCommentContentError::CommentDoesNotExist(
err.msg,
))
}
"CommentIdRequiredException" => {
return RusotoError::Service(DeleteCommentContentError::CommentIdRequired(
err.msg,
))
}
"InvalidCommentIdException" => {
return RusotoError::Service(DeleteCommentContentError::InvalidCommentId(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteCommentContentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteCommentContentError::CommentDeleted(ref cause) => write!(f, "{}", cause),
DeleteCommentContentError::CommentDoesNotExist(ref cause) => write!(f, "{}", cause),
DeleteCommentContentError::CommentIdRequired(ref cause) => write!(f, "{}", cause),
DeleteCommentContentError::InvalidCommentId(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteCommentContentError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFileError {
BranchDoesNotExist(String),
BranchNameIsTagName(String),
BranchNameRequired(String),
CommitMessageLengthExceeded(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FileDoesNotExist(String),
InvalidBranchName(String),
InvalidEmail(String),
InvalidParentCommitId(String),
InvalidPath(String),
InvalidRepositoryName(String),
NameLengthExceeded(String),
ParentCommitDoesNotExist(String),
ParentCommitIdOutdated(String),
ParentCommitIdRequired(String),
PathRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl DeleteFileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFileError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BranchDoesNotExistException" => {
return RusotoError::Service(DeleteFileError::BranchDoesNotExist(err.msg))
}
"BranchNameIsTagNameException" => {
return RusotoError::Service(DeleteFileError::BranchNameIsTagName(err.msg))
}
"BranchNameRequiredException" => {
return RusotoError::Service(DeleteFileError::BranchNameRequired(err.msg))
}
"CommitMessageLengthExceededException" => {
return RusotoError::Service(DeleteFileError::CommitMessageLengthExceeded(
err.msg,
))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(DeleteFileError::EncryptionIntegrityChecksFailed(
err.msg,
))
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(DeleteFileError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(DeleteFileError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(DeleteFileError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(DeleteFileError::EncryptionKeyUnavailable(err.msg))
}
"FileDoesNotExistException" => {
return RusotoError::Service(DeleteFileError::FileDoesNotExist(err.msg))
}
"InvalidBranchNameException" => {
return RusotoError::Service(DeleteFileError::InvalidBranchName(err.msg))
}
"InvalidEmailException" => {
return RusotoError::Service(DeleteFileError::InvalidEmail(err.msg))
}
"InvalidParentCommitIdException" => {
return RusotoError::Service(DeleteFileError::InvalidParentCommitId(err.msg))
}
"InvalidPathException" => {
return RusotoError::Service(DeleteFileError::InvalidPath(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(DeleteFileError::InvalidRepositoryName(err.msg))
}
"NameLengthExceededException" => {
return RusotoError::Service(DeleteFileError::NameLengthExceeded(err.msg))
}
"ParentCommitDoesNotExistException" => {
return RusotoError::Service(DeleteFileError::ParentCommitDoesNotExist(err.msg))
}
"ParentCommitIdOutdatedException" => {
return RusotoError::Service(DeleteFileError::ParentCommitIdOutdated(err.msg))
}
"ParentCommitIdRequiredException" => {
return RusotoError::Service(DeleteFileError::ParentCommitIdRequired(err.msg))
}
"PathRequiredException" => {
return RusotoError::Service(DeleteFileError::PathRequired(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(DeleteFileError::RepositoryDoesNotExist(err.msg))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(DeleteFileError::RepositoryNameRequired(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFileError::BranchDoesNotExist(ref cause) => write!(f, "{}", cause),
DeleteFileError::BranchNameIsTagName(ref cause) => write!(f, "{}", cause),
DeleteFileError::BranchNameRequired(ref cause) => write!(f, "{}", cause),
DeleteFileError::CommitMessageLengthExceeded(ref cause) => write!(f, "{}", cause),
DeleteFileError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
DeleteFileError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
DeleteFileError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
DeleteFileError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
DeleteFileError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
DeleteFileError::FileDoesNotExist(ref cause) => write!(f, "{}", cause),
DeleteFileError::InvalidBranchName(ref cause) => write!(f, "{}", cause),
DeleteFileError::InvalidEmail(ref cause) => write!(f, "{}", cause),
DeleteFileError::InvalidParentCommitId(ref cause) => write!(f, "{}", cause),
DeleteFileError::InvalidPath(ref cause) => write!(f, "{}", cause),
DeleteFileError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
DeleteFileError::NameLengthExceeded(ref cause) => write!(f, "{}", cause),
DeleteFileError::ParentCommitDoesNotExist(ref cause) => write!(f, "{}", cause),
DeleteFileError::ParentCommitIdOutdated(ref cause) => write!(f, "{}", cause),
DeleteFileError::ParentCommitIdRequired(ref cause) => write!(f, "{}", cause),
DeleteFileError::PathRequired(ref cause) => write!(f, "{}", cause),
DeleteFileError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
DeleteFileError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFileError {}
#[derive(Debug, PartialEq)]
pub enum DeletePullRequestApprovalRuleError {
ApprovalRuleNameRequired(String),
CannotDeleteApprovalRuleFromTemplate(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidApprovalRuleName(String),
InvalidPullRequestId(String),
PullRequestAlreadyClosed(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
}
impl DeletePullRequestApprovalRuleError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DeletePullRequestApprovalRuleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleNameRequiredException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::ApprovalRuleNameRequired(err.msg),
)
}
"CannotDeleteApprovalRuleFromTemplateException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::CannotDeleteApprovalRuleFromTemplate(
err.msg,
),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::EncryptionIntegrityChecksFailed(
err.msg,
),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidApprovalRuleNameException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::InvalidApprovalRuleName(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::InvalidPullRequestId(err.msg),
)
}
"PullRequestAlreadyClosedException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::PullRequestAlreadyClosed(err.msg),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
DeletePullRequestApprovalRuleError::PullRequestIdRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeletePullRequestApprovalRuleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeletePullRequestApprovalRuleError::ApprovalRuleNameRequired(ref cause) => {
write!(f, "{}", cause)
}
DeletePullRequestApprovalRuleError::CannotDeleteApprovalRuleFromTemplate(ref cause) => {
write!(f, "{}", cause)
}
DeletePullRequestApprovalRuleError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
DeletePullRequestApprovalRuleError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DeletePullRequestApprovalRuleError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
DeletePullRequestApprovalRuleError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
DeletePullRequestApprovalRuleError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DeletePullRequestApprovalRuleError::InvalidApprovalRuleName(ref cause) => {
write!(f, "{}", cause)
}
DeletePullRequestApprovalRuleError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
DeletePullRequestApprovalRuleError::PullRequestAlreadyClosed(ref cause) => {
write!(f, "{}", cause)
}
DeletePullRequestApprovalRuleError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
DeletePullRequestApprovalRuleError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DeletePullRequestApprovalRuleError {}
#[derive(Debug, PartialEq)]
pub enum DeleteRepositoryError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidRepositoryName(String),
RepositoryNameRequired(String),
}
impl DeleteRepositoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteRepositoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
DeleteRepositoryError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(DeleteRepositoryError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(DeleteRepositoryError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(DeleteRepositoryError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(DeleteRepositoryError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(DeleteRepositoryError::InvalidRepositoryName(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(DeleteRepositoryError::RepositoryNameRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteRepositoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteRepositoryError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
DeleteRepositoryError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
DeleteRepositoryError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
DeleteRepositoryError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
DeleteRepositoryError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
DeleteRepositoryError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
DeleteRepositoryError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteRepositoryError {}
#[derive(Debug, PartialEq)]
pub enum DescribeMergeConflictsError {
CommitDoesNotExist(String),
CommitRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FileDoesNotExist(String),
InvalidCommit(String),
InvalidConflictDetailLevel(String),
InvalidConflictResolutionStrategy(String),
InvalidContinuationToken(String),
InvalidMaxMergeHunks(String),
InvalidMergeOption(String),
InvalidPath(String),
InvalidRepositoryName(String),
MaximumFileContentToLoadExceeded(String),
MaximumItemsToCompareExceeded(String),
MergeOptionRequired(String),
PathRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
TipsDivergenceExceeded(String),
}
impl DescribeMergeConflictsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribeMergeConflictsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitDoesNotExistException" => {
return RusotoError::Service(DescribeMergeConflictsError::CommitDoesNotExist(
err.msg,
))
}
"CommitRequiredException" => {
return RusotoError::Service(DescribeMergeConflictsError::CommitRequired(
err.msg,
))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
DescribeMergeConflictsError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
DescribeMergeConflictsError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
DescribeMergeConflictsError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
DescribeMergeConflictsError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
DescribeMergeConflictsError::EncryptionKeyUnavailable(err.msg),
)
}
"FileDoesNotExistException" => {
return RusotoError::Service(DescribeMergeConflictsError::FileDoesNotExist(
err.msg,
))
}
"InvalidCommitException" => {
return RusotoError::Service(DescribeMergeConflictsError::InvalidCommit(
err.msg,
))
}
"InvalidConflictDetailLevelException" => {
return RusotoError::Service(
DescribeMergeConflictsError::InvalidConflictDetailLevel(err.msg),
)
}
"InvalidConflictResolutionStrategyException" => {
return RusotoError::Service(
DescribeMergeConflictsError::InvalidConflictResolutionStrategy(err.msg),
)
}
"InvalidContinuationTokenException" => {
return RusotoError::Service(
DescribeMergeConflictsError::InvalidContinuationToken(err.msg),
)
}
"InvalidMaxMergeHunksException" => {
return RusotoError::Service(DescribeMergeConflictsError::InvalidMaxMergeHunks(
err.msg,
))
}
"InvalidMergeOptionException" => {
return RusotoError::Service(DescribeMergeConflictsError::InvalidMergeOption(
err.msg,
))
}
"InvalidPathException" => {
return RusotoError::Service(DescribeMergeConflictsError::InvalidPath(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
DescribeMergeConflictsError::InvalidRepositoryName(err.msg),
)
}
"MaximumFileContentToLoadExceededException" => {
return RusotoError::Service(
DescribeMergeConflictsError::MaximumFileContentToLoadExceeded(err.msg),
)
}
"MaximumItemsToCompareExceededException" => {
return RusotoError::Service(
DescribeMergeConflictsError::MaximumItemsToCompareExceeded(err.msg),
)
}
"MergeOptionRequiredException" => {
return RusotoError::Service(DescribeMergeConflictsError::MergeOptionRequired(
err.msg,
))
}
"PathRequiredException" => {
return RusotoError::Service(DescribeMergeConflictsError::PathRequired(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
DescribeMergeConflictsError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
DescribeMergeConflictsError::RepositoryNameRequired(err.msg),
)
}
"TipsDivergenceExceededException" => {
return RusotoError::Service(
DescribeMergeConflictsError::TipsDivergenceExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribeMergeConflictsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribeMergeConflictsError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::CommitRequired(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
DescribeMergeConflictsError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DescribeMergeConflictsError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DescribeMergeConflictsError::FileDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::InvalidCommit(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::InvalidConflictDetailLevel(ref cause) => {
write!(f, "{}", cause)
}
DescribeMergeConflictsError::InvalidConflictResolutionStrategy(ref cause) => {
write!(f, "{}", cause)
}
DescribeMergeConflictsError::InvalidContinuationToken(ref cause) => {
write!(f, "{}", cause)
}
DescribeMergeConflictsError::InvalidMaxMergeHunks(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::InvalidMergeOption(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::InvalidPath(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::MaximumFileContentToLoadExceeded(ref cause) => {
write!(f, "{}", cause)
}
DescribeMergeConflictsError::MaximumItemsToCompareExceeded(ref cause) => {
write!(f, "{}", cause)
}
DescribeMergeConflictsError::MergeOptionRequired(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::PathRequired(ref cause) => write!(f, "{}", cause),
DescribeMergeConflictsError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
DescribeMergeConflictsError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
DescribeMergeConflictsError::TipsDivergenceExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribeMergeConflictsError {}
#[derive(Debug, PartialEq)]
pub enum DescribePullRequestEventsError {
ActorDoesNotExist(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidActorArn(String),
InvalidContinuationToken(String),
InvalidMaxResults(String),
InvalidPullRequestEventType(String),
InvalidPullRequestId(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
}
impl DescribePullRequestEventsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DescribePullRequestEventsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ActorDoesNotExistException" => {
return RusotoError::Service(DescribePullRequestEventsError::ActorDoesNotExist(
err.msg,
))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
DescribePullRequestEventsError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
DescribePullRequestEventsError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
DescribePullRequestEventsError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
DescribePullRequestEventsError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
DescribePullRequestEventsError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidActorArnException" => {
return RusotoError::Service(DescribePullRequestEventsError::InvalidActorArn(
err.msg,
))
}
"InvalidContinuationTokenException" => {
return RusotoError::Service(
DescribePullRequestEventsError::InvalidContinuationToken(err.msg),
)
}
"InvalidMaxResultsException" => {
return RusotoError::Service(DescribePullRequestEventsError::InvalidMaxResults(
err.msg,
))
}
"InvalidPullRequestEventTypeException" => {
return RusotoError::Service(
DescribePullRequestEventsError::InvalidPullRequestEventType(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
DescribePullRequestEventsError::InvalidPullRequestId(err.msg),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
DescribePullRequestEventsError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
DescribePullRequestEventsError::PullRequestIdRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DescribePullRequestEventsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DescribePullRequestEventsError::ActorDoesNotExist(ref cause) => write!(f, "{}", cause),
DescribePullRequestEventsError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
DescribePullRequestEventsError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
DescribePullRequestEventsError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
DescribePullRequestEventsError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
DescribePullRequestEventsError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
DescribePullRequestEventsError::InvalidActorArn(ref cause) => write!(f, "{}", cause),
DescribePullRequestEventsError::InvalidContinuationToken(ref cause) => {
write!(f, "{}", cause)
}
DescribePullRequestEventsError::InvalidMaxResults(ref cause) => write!(f, "{}", cause),
DescribePullRequestEventsError::InvalidPullRequestEventType(ref cause) => {
write!(f, "{}", cause)
}
DescribePullRequestEventsError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
DescribePullRequestEventsError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
DescribePullRequestEventsError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for DescribePullRequestEventsError {}
#[derive(Debug, PartialEq)]
pub enum DisassociateApprovalRuleTemplateFromRepositoryError {
ApprovalRuleTemplateDoesNotExist(String),
ApprovalRuleTemplateNameRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidApprovalRuleTemplateName(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl DisassociateApprovalRuleTemplateFromRepositoryError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<DisassociateApprovalRuleTemplateFromRepositoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleTemplateDoesNotExistException" => return RusotoError::Service(DisassociateApprovalRuleTemplateFromRepositoryError::ApprovalRuleTemplateDoesNotExist(err.msg)),
"ApprovalRuleTemplateNameRequiredException" => return RusotoError::Service(DisassociateApprovalRuleTemplateFromRepositoryError::ApprovalRuleTemplateNameRequired(err.msg)),
"EncryptionIntegrityChecksFailedException" => return RusotoError::Service(DisassociateApprovalRuleTemplateFromRepositoryError::EncryptionIntegrityChecksFailed(err.msg)),
"EncryptionKeyAccessDeniedException" => return RusotoError::Service(DisassociateApprovalRuleTemplateFromRepositoryError::EncryptionKeyAccessDenied(err.msg)),
"EncryptionKeyDisabledException" => return RusotoError::Service(DisassociateApprovalRuleTemplateFromRepositoryError::EncryptionKeyDisabled(err.msg)),
"EncryptionKeyNotFoundException" => return RusotoError::Service(DisassociateApprovalRuleTemplateFromRepositoryError::EncryptionKeyNotFound(err.msg)),
"EncryptionKeyUnavailableException" => return RusotoError::Service(DisassociateApprovalRuleTemplateFromRepositoryError::EncryptionKeyUnavailable(err.msg)),
"InvalidApprovalRuleTemplateNameException" => return RusotoError::Service(DisassociateApprovalRuleTemplateFromRepositoryError::InvalidApprovalRuleTemplateName(err.msg)),
"InvalidRepositoryNameException" => return RusotoError::Service(DisassociateApprovalRuleTemplateFromRepositoryError::InvalidRepositoryName(err.msg)),
"RepositoryDoesNotExistException" => return RusotoError::Service(DisassociateApprovalRuleTemplateFromRepositoryError::RepositoryDoesNotExist(err.msg)),
"RepositoryNameRequiredException" => return RusotoError::Service(DisassociateApprovalRuleTemplateFromRepositoryError::RepositoryNameRequired(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisassociateApprovalRuleTemplateFromRepositoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisassociateApprovalRuleTemplateFromRepositoryError::ApprovalRuleTemplateDoesNotExist(ref cause) => write!(f, "{}", cause),
DisassociateApprovalRuleTemplateFromRepositoryError::ApprovalRuleTemplateNameRequired(ref cause) => write!(f, "{}", cause),
DisassociateApprovalRuleTemplateFromRepositoryError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
DisassociateApprovalRuleTemplateFromRepositoryError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
DisassociateApprovalRuleTemplateFromRepositoryError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
DisassociateApprovalRuleTemplateFromRepositoryError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
DisassociateApprovalRuleTemplateFromRepositoryError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
DisassociateApprovalRuleTemplateFromRepositoryError::InvalidApprovalRuleTemplateName(ref cause) => write!(f, "{}", cause),
DisassociateApprovalRuleTemplateFromRepositoryError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
DisassociateApprovalRuleTemplateFromRepositoryError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
DisassociateApprovalRuleTemplateFromRepositoryError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for DisassociateApprovalRuleTemplateFromRepositoryError {}
#[derive(Debug, PartialEq)]
pub enum EvaluatePullRequestApprovalRulesError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidPullRequestId(String),
InvalidRevisionId(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
RevisionIdRequired(String),
RevisionNotCurrent(String),
}
impl EvaluatePullRequestApprovalRulesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<EvaluatePullRequestApprovalRulesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
EvaluatePullRequestApprovalRulesError::EncryptionIntegrityChecksFailed(
err.msg,
),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
EvaluatePullRequestApprovalRulesError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
EvaluatePullRequestApprovalRulesError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
EvaluatePullRequestApprovalRulesError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
EvaluatePullRequestApprovalRulesError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
EvaluatePullRequestApprovalRulesError::InvalidPullRequestId(err.msg),
)
}
"InvalidRevisionIdException" => {
return RusotoError::Service(
EvaluatePullRequestApprovalRulesError::InvalidRevisionId(err.msg),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
EvaluatePullRequestApprovalRulesError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
EvaluatePullRequestApprovalRulesError::PullRequestIdRequired(err.msg),
)
}
"RevisionIdRequiredException" => {
return RusotoError::Service(
EvaluatePullRequestApprovalRulesError::RevisionIdRequired(err.msg),
)
}
"RevisionNotCurrentException" => {
return RusotoError::Service(
EvaluatePullRequestApprovalRulesError::RevisionNotCurrent(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for EvaluatePullRequestApprovalRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EvaluatePullRequestApprovalRulesError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
EvaluatePullRequestApprovalRulesError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
EvaluatePullRequestApprovalRulesError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
EvaluatePullRequestApprovalRulesError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
EvaluatePullRequestApprovalRulesError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
EvaluatePullRequestApprovalRulesError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
EvaluatePullRequestApprovalRulesError::InvalidRevisionId(ref cause) => {
write!(f, "{}", cause)
}
EvaluatePullRequestApprovalRulesError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
EvaluatePullRequestApprovalRulesError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
EvaluatePullRequestApprovalRulesError::RevisionIdRequired(ref cause) => {
write!(f, "{}", cause)
}
EvaluatePullRequestApprovalRulesError::RevisionNotCurrent(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for EvaluatePullRequestApprovalRulesError {}
#[derive(Debug, PartialEq)]
pub enum GetApprovalRuleTemplateError {
ApprovalRuleTemplateDoesNotExist(String),
ApprovalRuleTemplateNameRequired(String),
InvalidApprovalRuleTemplateName(String),
}
impl GetApprovalRuleTemplateError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetApprovalRuleTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleTemplateDoesNotExistException" => {
return RusotoError::Service(
GetApprovalRuleTemplateError::ApprovalRuleTemplateDoesNotExist(err.msg),
)
}
"ApprovalRuleTemplateNameRequiredException" => {
return RusotoError::Service(
GetApprovalRuleTemplateError::ApprovalRuleTemplateNameRequired(err.msg),
)
}
"InvalidApprovalRuleTemplateNameException" => {
return RusotoError::Service(
GetApprovalRuleTemplateError::InvalidApprovalRuleTemplateName(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetApprovalRuleTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetApprovalRuleTemplateError::ApprovalRuleTemplateDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetApprovalRuleTemplateError::ApprovalRuleTemplateNameRequired(ref cause) => {
write!(f, "{}", cause)
}
GetApprovalRuleTemplateError::InvalidApprovalRuleTemplateName(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetApprovalRuleTemplateError {}
#[derive(Debug, PartialEq)]
pub enum GetBlobError {
BlobIdDoesNotExist(String),
BlobIdRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FileTooLarge(String),
InvalidBlobId(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl GetBlobError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBlobError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BlobIdDoesNotExistException" => {
return RusotoError::Service(GetBlobError::BlobIdDoesNotExist(err.msg))
}
"BlobIdRequiredException" => {
return RusotoError::Service(GetBlobError::BlobIdRequired(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(GetBlobError::EncryptionIntegrityChecksFailed(
err.msg,
))
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetBlobError::EncryptionKeyAccessDenied(err.msg))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetBlobError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetBlobError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetBlobError::EncryptionKeyUnavailable(err.msg))
}
"FileTooLargeException" => {
return RusotoError::Service(GetBlobError::FileTooLarge(err.msg))
}
"InvalidBlobIdException" => {
return RusotoError::Service(GetBlobError::InvalidBlobId(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(GetBlobError::InvalidRepositoryName(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(GetBlobError::RepositoryDoesNotExist(err.msg))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(GetBlobError::RepositoryNameRequired(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetBlobError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetBlobError::BlobIdDoesNotExist(ref cause) => write!(f, "{}", cause),
GetBlobError::BlobIdRequired(ref cause) => write!(f, "{}", cause),
GetBlobError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
GetBlobError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetBlobError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetBlobError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetBlobError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetBlobError::FileTooLarge(ref cause) => write!(f, "{}", cause),
GetBlobError::InvalidBlobId(ref cause) => write!(f, "{}", cause),
GetBlobError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
GetBlobError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
GetBlobError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBlobError {}
#[derive(Debug, PartialEq)]
pub enum GetBranchError {
BranchDoesNotExist(String),
BranchNameRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidBranchName(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl GetBranchError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetBranchError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BranchDoesNotExistException" => {
return RusotoError::Service(GetBranchError::BranchDoesNotExist(err.msg))
}
"BranchNameRequiredException" => {
return RusotoError::Service(GetBranchError::BranchNameRequired(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(GetBranchError::EncryptionIntegrityChecksFailed(
err.msg,
))
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetBranchError::EncryptionKeyAccessDenied(err.msg))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetBranchError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetBranchError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetBranchError::EncryptionKeyUnavailable(err.msg))
}
"InvalidBranchNameException" => {
return RusotoError::Service(GetBranchError::InvalidBranchName(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(GetBranchError::InvalidRepositoryName(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(GetBranchError::RepositoryDoesNotExist(err.msg))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(GetBranchError::RepositoryNameRequired(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::BranchDoesNotExist(ref cause) => write!(f, "{}", cause),
GetBranchError::BranchNameRequired(ref cause) => write!(f, "{}", cause),
GetBranchError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
GetBranchError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetBranchError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetBranchError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetBranchError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetBranchError::InvalidBranchName(ref cause) => write!(f, "{}", cause),
GetBranchError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
GetBranchError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
GetBranchError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetBranchError {}
#[derive(Debug, PartialEq)]
pub enum GetCommentError {
CommentDeleted(String),
CommentDoesNotExist(String),
CommentIdRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidCommentId(String),
}
impl GetCommentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCommentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommentDeletedException" => {
return RusotoError::Service(GetCommentError::CommentDeleted(err.msg))
}
"CommentDoesNotExistException" => {
return RusotoError::Service(GetCommentError::CommentDoesNotExist(err.msg))
}
"CommentIdRequiredException" => {
return RusotoError::Service(GetCommentError::CommentIdRequired(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(GetCommentError::EncryptionIntegrityChecksFailed(
err.msg,
))
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetCommentError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetCommentError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetCommentError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetCommentError::EncryptionKeyUnavailable(err.msg))
}
"InvalidCommentIdException" => {
return RusotoError::Service(GetCommentError::InvalidCommentId(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCommentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCommentError::CommentDeleted(ref cause) => write!(f, "{}", cause),
GetCommentError::CommentDoesNotExist(ref cause) => write!(f, "{}", cause),
GetCommentError::CommentIdRequired(ref cause) => write!(f, "{}", cause),
GetCommentError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
GetCommentError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetCommentError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetCommentError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetCommentError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetCommentError::InvalidCommentId(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCommentError {}
#[derive(Debug, PartialEq)]
pub enum GetCommentReactionsError {
CommentDeleted(String),
CommentDoesNotExist(String),
CommentIdRequired(String),
InvalidCommentId(String),
InvalidContinuationToken(String),
InvalidMaxResults(String),
InvalidReactionUserArn(String),
}
impl GetCommentReactionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCommentReactionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommentDeletedException" => {
return RusotoError::Service(GetCommentReactionsError::CommentDeleted(err.msg))
}
"CommentDoesNotExistException" => {
return RusotoError::Service(GetCommentReactionsError::CommentDoesNotExist(
err.msg,
))
}
"CommentIdRequiredException" => {
return RusotoError::Service(GetCommentReactionsError::CommentIdRequired(
err.msg,
))
}
"InvalidCommentIdException" => {
return RusotoError::Service(GetCommentReactionsError::InvalidCommentId(
err.msg,
))
}
"InvalidContinuationTokenException" => {
return RusotoError::Service(
GetCommentReactionsError::InvalidContinuationToken(err.msg),
)
}
"InvalidMaxResultsException" => {
return RusotoError::Service(GetCommentReactionsError::InvalidMaxResults(
err.msg,
))
}
"InvalidReactionUserArnException" => {
return RusotoError::Service(GetCommentReactionsError::InvalidReactionUserArn(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCommentReactionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCommentReactionsError::CommentDeleted(ref cause) => write!(f, "{}", cause),
GetCommentReactionsError::CommentDoesNotExist(ref cause) => write!(f, "{}", cause),
GetCommentReactionsError::CommentIdRequired(ref cause) => write!(f, "{}", cause),
GetCommentReactionsError::InvalidCommentId(ref cause) => write!(f, "{}", cause),
GetCommentReactionsError::InvalidContinuationToken(ref cause) => write!(f, "{}", cause),
GetCommentReactionsError::InvalidMaxResults(ref cause) => write!(f, "{}", cause),
GetCommentReactionsError::InvalidReactionUserArn(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCommentReactionsError {}
#[derive(Debug, PartialEq)]
pub enum GetCommentsForComparedCommitError {
CommitDoesNotExist(String),
CommitIdRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidCommitId(String),
InvalidContinuationToken(String),
InvalidMaxResults(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl GetCommentsForComparedCommitError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetCommentsForComparedCommitError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitDoesNotExistException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::CommitDoesNotExist(err.msg),
)
}
"CommitIdRequiredException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::CommitIdRequired(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidCommitIdException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::InvalidCommitId(err.msg),
)
}
"InvalidContinuationTokenException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::InvalidContinuationToken(err.msg),
)
}
"InvalidMaxResultsException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::InvalidMaxResults(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::InvalidRepositoryName(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
GetCommentsForComparedCommitError::RepositoryNameRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCommentsForComparedCommitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCommentsForComparedCommitError::CommitDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForComparedCommitError::CommitIdRequired(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForComparedCommitError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForComparedCommitError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForComparedCommitError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForComparedCommitError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForComparedCommitError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForComparedCommitError::InvalidCommitId(ref cause) => write!(f, "{}", cause),
GetCommentsForComparedCommitError::InvalidContinuationToken(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForComparedCommitError::InvalidMaxResults(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForComparedCommitError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForComparedCommitError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForComparedCommitError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetCommentsForComparedCommitError {}
#[derive(Debug, PartialEq)]
pub enum GetCommentsForPullRequestError {
CommitDoesNotExist(String),
CommitIdRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidCommitId(String),
InvalidContinuationToken(String),
InvalidMaxResults(String),
InvalidPullRequestId(String),
InvalidRepositoryName(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
RepositoryNotAssociatedWithPullRequest(String),
}
impl GetCommentsForPullRequestError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCommentsForPullRequestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitDoesNotExistException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::CommitDoesNotExist(err.msg),
)
}
"CommitIdRequiredException" => {
return RusotoError::Service(GetCommentsForPullRequestError::CommitIdRequired(
err.msg,
))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidCommitIdException" => {
return RusotoError::Service(GetCommentsForPullRequestError::InvalidCommitId(
err.msg,
))
}
"InvalidContinuationTokenException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::InvalidContinuationToken(err.msg),
)
}
"InvalidMaxResultsException" => {
return RusotoError::Service(GetCommentsForPullRequestError::InvalidMaxResults(
err.msg,
))
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::InvalidPullRequestId(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::InvalidRepositoryName(err.msg),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::PullRequestIdRequired(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::RepositoryNameRequired(err.msg),
)
}
"RepositoryNotAssociatedWithPullRequestException" => {
return RusotoError::Service(
GetCommentsForPullRequestError::RepositoryNotAssociatedWithPullRequest(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCommentsForPullRequestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCommentsForPullRequestError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
GetCommentsForPullRequestError::CommitIdRequired(ref cause) => write!(f, "{}", cause),
GetCommentsForPullRequestError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::InvalidCommitId(ref cause) => write!(f, "{}", cause),
GetCommentsForPullRequestError::InvalidContinuationToken(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::InvalidMaxResults(ref cause) => write!(f, "{}", cause),
GetCommentsForPullRequestError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
GetCommentsForPullRequestError::RepositoryNotAssociatedWithPullRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetCommentsForPullRequestError {}
#[derive(Debug, PartialEq)]
pub enum GetCommitError {
CommitIdDoesNotExist(String),
CommitIdRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidCommitId(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl GetCommitError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetCommitError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitIdDoesNotExistException" => {
return RusotoError::Service(GetCommitError::CommitIdDoesNotExist(err.msg))
}
"CommitIdRequiredException" => {
return RusotoError::Service(GetCommitError::CommitIdRequired(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(GetCommitError::EncryptionIntegrityChecksFailed(
err.msg,
))
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetCommitError::EncryptionKeyAccessDenied(err.msg))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetCommitError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetCommitError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetCommitError::EncryptionKeyUnavailable(err.msg))
}
"InvalidCommitIdException" => {
return RusotoError::Service(GetCommitError::InvalidCommitId(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(GetCommitError::InvalidRepositoryName(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(GetCommitError::RepositoryDoesNotExist(err.msg))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(GetCommitError::RepositoryNameRequired(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetCommitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetCommitError::CommitIdDoesNotExist(ref cause) => write!(f, "{}", cause),
GetCommitError::CommitIdRequired(ref cause) => write!(f, "{}", cause),
GetCommitError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
GetCommitError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetCommitError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetCommitError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetCommitError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetCommitError::InvalidCommitId(ref cause) => write!(f, "{}", cause),
GetCommitError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
GetCommitError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
GetCommitError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetCommitError {}
#[derive(Debug, PartialEq)]
pub enum GetDifferencesError {
CommitDoesNotExist(String),
CommitRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidCommit(String),
InvalidCommitId(String),
InvalidContinuationToken(String),
InvalidMaxResults(String),
InvalidPath(String),
InvalidRepositoryName(String),
PathDoesNotExist(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl GetDifferencesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDifferencesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitDoesNotExistException" => {
return RusotoError::Service(GetDifferencesError::CommitDoesNotExist(err.msg))
}
"CommitRequiredException" => {
return RusotoError::Service(GetDifferencesError::CommitRequired(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
GetDifferencesError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetDifferencesError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetDifferencesError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetDifferencesError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetDifferencesError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidCommitException" => {
return RusotoError::Service(GetDifferencesError::InvalidCommit(err.msg))
}
"InvalidCommitIdException" => {
return RusotoError::Service(GetDifferencesError::InvalidCommitId(err.msg))
}
"InvalidContinuationTokenException" => {
return RusotoError::Service(GetDifferencesError::InvalidContinuationToken(
err.msg,
))
}
"InvalidMaxResultsException" => {
return RusotoError::Service(GetDifferencesError::InvalidMaxResults(err.msg))
}
"InvalidPathException" => {
return RusotoError::Service(GetDifferencesError::InvalidPath(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(GetDifferencesError::InvalidRepositoryName(
err.msg,
))
}
"PathDoesNotExistException" => {
return RusotoError::Service(GetDifferencesError::PathDoesNotExist(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(GetDifferencesError::RepositoryDoesNotExist(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(GetDifferencesError::RepositoryNameRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDifferencesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDifferencesError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
GetDifferencesError::CommitRequired(ref cause) => write!(f, "{}", cause),
GetDifferencesError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
GetDifferencesError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetDifferencesError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetDifferencesError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetDifferencesError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetDifferencesError::InvalidCommit(ref cause) => write!(f, "{}", cause),
GetDifferencesError::InvalidCommitId(ref cause) => write!(f, "{}", cause),
GetDifferencesError::InvalidContinuationToken(ref cause) => write!(f, "{}", cause),
GetDifferencesError::InvalidMaxResults(ref cause) => write!(f, "{}", cause),
GetDifferencesError::InvalidPath(ref cause) => write!(f, "{}", cause),
GetDifferencesError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
GetDifferencesError::PathDoesNotExist(ref cause) => write!(f, "{}", cause),
GetDifferencesError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
GetDifferencesError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDifferencesError {}
#[derive(Debug, PartialEq)]
pub enum GetFileError {
CommitDoesNotExist(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FileDoesNotExist(String),
FileTooLarge(String),
InvalidCommit(String),
InvalidPath(String),
InvalidRepositoryName(String),
PathRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl GetFileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFileError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitDoesNotExistException" => {
return RusotoError::Service(GetFileError::CommitDoesNotExist(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(GetFileError::EncryptionIntegrityChecksFailed(
err.msg,
))
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetFileError::EncryptionKeyAccessDenied(err.msg))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetFileError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetFileError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetFileError::EncryptionKeyUnavailable(err.msg))
}
"FileDoesNotExistException" => {
return RusotoError::Service(GetFileError::FileDoesNotExist(err.msg))
}
"FileTooLargeException" => {
return RusotoError::Service(GetFileError::FileTooLarge(err.msg))
}
"InvalidCommitException" => {
return RusotoError::Service(GetFileError::InvalidCommit(err.msg))
}
"InvalidPathException" => {
return RusotoError::Service(GetFileError::InvalidPath(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(GetFileError::InvalidRepositoryName(err.msg))
}
"PathRequiredException" => {
return RusotoError::Service(GetFileError::PathRequired(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(GetFileError::RepositoryDoesNotExist(err.msg))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(GetFileError::RepositoryNameRequired(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFileError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
GetFileError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
GetFileError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetFileError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetFileError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetFileError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetFileError::FileDoesNotExist(ref cause) => write!(f, "{}", cause),
GetFileError::FileTooLarge(ref cause) => write!(f, "{}", cause),
GetFileError::InvalidCommit(ref cause) => write!(f, "{}", cause),
GetFileError::InvalidPath(ref cause) => write!(f, "{}", cause),
GetFileError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
GetFileError::PathRequired(ref cause) => write!(f, "{}", cause),
GetFileError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
GetFileError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFileError {}
#[derive(Debug, PartialEq)]
pub enum GetFolderError {
CommitDoesNotExist(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FolderDoesNotExist(String),
InvalidCommit(String),
InvalidPath(String),
InvalidRepositoryName(String),
PathRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl GetFolderError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFolderError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitDoesNotExistException" => {
return RusotoError::Service(GetFolderError::CommitDoesNotExist(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(GetFolderError::EncryptionIntegrityChecksFailed(
err.msg,
))
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetFolderError::EncryptionKeyAccessDenied(err.msg))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetFolderError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetFolderError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetFolderError::EncryptionKeyUnavailable(err.msg))
}
"FolderDoesNotExistException" => {
return RusotoError::Service(GetFolderError::FolderDoesNotExist(err.msg))
}
"InvalidCommitException" => {
return RusotoError::Service(GetFolderError::InvalidCommit(err.msg))
}
"InvalidPathException" => {
return RusotoError::Service(GetFolderError::InvalidPath(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(GetFolderError::InvalidRepositoryName(err.msg))
}
"PathRequiredException" => {
return RusotoError::Service(GetFolderError::PathRequired(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(GetFolderError::RepositoryDoesNotExist(err.msg))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(GetFolderError::RepositoryNameRequired(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFolderError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFolderError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
GetFolderError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
GetFolderError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetFolderError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetFolderError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetFolderError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetFolderError::FolderDoesNotExist(ref cause) => write!(f, "{}", cause),
GetFolderError::InvalidCommit(ref cause) => write!(f, "{}", cause),
GetFolderError::InvalidPath(ref cause) => write!(f, "{}", cause),
GetFolderError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
GetFolderError::PathRequired(ref cause) => write!(f, "{}", cause),
GetFolderError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
GetFolderError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFolderError {}
#[derive(Debug, PartialEq)]
pub enum GetMergeCommitError {
CommitDoesNotExist(String),
CommitRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidCommit(String),
InvalidConflictDetailLevel(String),
InvalidConflictResolutionStrategy(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl GetMergeCommitError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMergeCommitError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitDoesNotExistException" => {
return RusotoError::Service(GetMergeCommitError::CommitDoesNotExist(err.msg))
}
"CommitRequiredException" => {
return RusotoError::Service(GetMergeCommitError::CommitRequired(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
GetMergeCommitError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetMergeCommitError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetMergeCommitError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetMergeCommitError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetMergeCommitError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidCommitException" => {
return RusotoError::Service(GetMergeCommitError::InvalidCommit(err.msg))
}
"InvalidConflictDetailLevelException" => {
return RusotoError::Service(GetMergeCommitError::InvalidConflictDetailLevel(
err.msg,
))
}
"InvalidConflictResolutionStrategyException" => {
return RusotoError::Service(
GetMergeCommitError::InvalidConflictResolutionStrategy(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(GetMergeCommitError::InvalidRepositoryName(
err.msg,
))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(GetMergeCommitError::RepositoryDoesNotExist(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(GetMergeCommitError::RepositoryNameRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMergeCommitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMergeCommitError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
GetMergeCommitError::CommitRequired(ref cause) => write!(f, "{}", cause),
GetMergeCommitError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
GetMergeCommitError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetMergeCommitError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetMergeCommitError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetMergeCommitError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetMergeCommitError::InvalidCommit(ref cause) => write!(f, "{}", cause),
GetMergeCommitError::InvalidConflictDetailLevel(ref cause) => write!(f, "{}", cause),
GetMergeCommitError::InvalidConflictResolutionStrategy(ref cause) => {
write!(f, "{}", cause)
}
GetMergeCommitError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
GetMergeCommitError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
GetMergeCommitError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMergeCommitError {}
#[derive(Debug, PartialEq)]
pub enum GetMergeConflictsError {
CommitDoesNotExist(String),
CommitRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidCommit(String),
InvalidConflictDetailLevel(String),
InvalidConflictResolutionStrategy(String),
InvalidContinuationToken(String),
InvalidDestinationCommitSpecifier(String),
InvalidMaxConflictFiles(String),
InvalidMergeOption(String),
InvalidRepositoryName(String),
InvalidSourceCommitSpecifier(String),
MaximumFileContentToLoadExceeded(String),
MaximumItemsToCompareExceeded(String),
MergeOptionRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
TipsDivergenceExceeded(String),
}
impl GetMergeConflictsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMergeConflictsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitDoesNotExistException" => {
return RusotoError::Service(GetMergeConflictsError::CommitDoesNotExist(
err.msg,
))
}
"CommitRequiredException" => {
return RusotoError::Service(GetMergeConflictsError::CommitRequired(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
GetMergeConflictsError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetMergeConflictsError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetMergeConflictsError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetMergeConflictsError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetMergeConflictsError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidCommitException" => {
return RusotoError::Service(GetMergeConflictsError::InvalidCommit(err.msg))
}
"InvalidConflictDetailLevelException" => {
return RusotoError::Service(
GetMergeConflictsError::InvalidConflictDetailLevel(err.msg),
)
}
"InvalidConflictResolutionStrategyException" => {
return RusotoError::Service(
GetMergeConflictsError::InvalidConflictResolutionStrategy(err.msg),
)
}
"InvalidContinuationTokenException" => {
return RusotoError::Service(GetMergeConflictsError::InvalidContinuationToken(
err.msg,
))
}
"InvalidDestinationCommitSpecifierException" => {
return RusotoError::Service(
GetMergeConflictsError::InvalidDestinationCommitSpecifier(err.msg),
)
}
"InvalidMaxConflictFilesException" => {
return RusotoError::Service(GetMergeConflictsError::InvalidMaxConflictFiles(
err.msg,
))
}
"InvalidMergeOptionException" => {
return RusotoError::Service(GetMergeConflictsError::InvalidMergeOption(
err.msg,
))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(GetMergeConflictsError::InvalidRepositoryName(
err.msg,
))
}
"InvalidSourceCommitSpecifierException" => {
return RusotoError::Service(
GetMergeConflictsError::InvalidSourceCommitSpecifier(err.msg),
)
}
"MaximumFileContentToLoadExceededException" => {
return RusotoError::Service(
GetMergeConflictsError::MaximumFileContentToLoadExceeded(err.msg),
)
}
"MaximumItemsToCompareExceededException" => {
return RusotoError::Service(
GetMergeConflictsError::MaximumItemsToCompareExceeded(err.msg),
)
}
"MergeOptionRequiredException" => {
return RusotoError::Service(GetMergeConflictsError::MergeOptionRequired(
err.msg,
))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(GetMergeConflictsError::RepositoryDoesNotExist(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(GetMergeConflictsError::RepositoryNameRequired(
err.msg,
))
}
"TipsDivergenceExceededException" => {
return RusotoError::Service(GetMergeConflictsError::TipsDivergenceExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMergeConflictsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMergeConflictsError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::CommitRequired(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
GetMergeConflictsError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::InvalidCommit(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::InvalidConflictDetailLevel(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::InvalidConflictResolutionStrategy(ref cause) => {
write!(f, "{}", cause)
}
GetMergeConflictsError::InvalidContinuationToken(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::InvalidDestinationCommitSpecifier(ref cause) => {
write!(f, "{}", cause)
}
GetMergeConflictsError::InvalidMaxConflictFiles(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::InvalidMergeOption(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::InvalidSourceCommitSpecifier(ref cause) => {
write!(f, "{}", cause)
}
GetMergeConflictsError::MaximumFileContentToLoadExceeded(ref cause) => {
write!(f, "{}", cause)
}
GetMergeConflictsError::MaximumItemsToCompareExceeded(ref cause) => {
write!(f, "{}", cause)
}
GetMergeConflictsError::MergeOptionRequired(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
GetMergeConflictsError::TipsDivergenceExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMergeConflictsError {}
#[derive(Debug, PartialEq)]
pub enum GetMergeOptionsError {
CommitDoesNotExist(String),
CommitRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidCommit(String),
InvalidConflictDetailLevel(String),
InvalidConflictResolutionStrategy(String),
InvalidRepositoryName(String),
MaximumFileContentToLoadExceeded(String),
MaximumItemsToCompareExceeded(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
TipsDivergenceExceeded(String),
}
impl GetMergeOptionsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetMergeOptionsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitDoesNotExistException" => {
return RusotoError::Service(GetMergeOptionsError::CommitDoesNotExist(err.msg))
}
"CommitRequiredException" => {
return RusotoError::Service(GetMergeOptionsError::CommitRequired(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
GetMergeOptionsError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetMergeOptionsError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetMergeOptionsError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetMergeOptionsError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetMergeOptionsError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidCommitException" => {
return RusotoError::Service(GetMergeOptionsError::InvalidCommit(err.msg))
}
"InvalidConflictDetailLevelException" => {
return RusotoError::Service(GetMergeOptionsError::InvalidConflictDetailLevel(
err.msg,
))
}
"InvalidConflictResolutionStrategyException" => {
return RusotoError::Service(
GetMergeOptionsError::InvalidConflictResolutionStrategy(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(GetMergeOptionsError::InvalidRepositoryName(
err.msg,
))
}
"MaximumFileContentToLoadExceededException" => {
return RusotoError::Service(
GetMergeOptionsError::MaximumFileContentToLoadExceeded(err.msg),
)
}
"MaximumItemsToCompareExceededException" => {
return RusotoError::Service(
GetMergeOptionsError::MaximumItemsToCompareExceeded(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(GetMergeOptionsError::RepositoryDoesNotExist(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(GetMergeOptionsError::RepositoryNameRequired(
err.msg,
))
}
"TipsDivergenceExceededException" => {
return RusotoError::Service(GetMergeOptionsError::TipsDivergenceExceeded(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetMergeOptionsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetMergeOptionsError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
GetMergeOptionsError::CommitRequired(ref cause) => write!(f, "{}", cause),
GetMergeOptionsError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
GetMergeOptionsError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetMergeOptionsError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetMergeOptionsError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetMergeOptionsError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetMergeOptionsError::InvalidCommit(ref cause) => write!(f, "{}", cause),
GetMergeOptionsError::InvalidConflictDetailLevel(ref cause) => write!(f, "{}", cause),
GetMergeOptionsError::InvalidConflictResolutionStrategy(ref cause) => {
write!(f, "{}", cause)
}
GetMergeOptionsError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
GetMergeOptionsError::MaximumFileContentToLoadExceeded(ref cause) => {
write!(f, "{}", cause)
}
GetMergeOptionsError::MaximumItemsToCompareExceeded(ref cause) => {
write!(f, "{}", cause)
}
GetMergeOptionsError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
GetMergeOptionsError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
GetMergeOptionsError::TipsDivergenceExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetMergeOptionsError {}
#[derive(Debug, PartialEq)]
pub enum GetPullRequestError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidPullRequestId(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
}
impl GetPullRequestError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetPullRequestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
GetPullRequestError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetPullRequestError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetPullRequestError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetPullRequestError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetPullRequestError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(GetPullRequestError::InvalidPullRequestId(err.msg))
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(GetPullRequestError::PullRequestDoesNotExist(
err.msg,
))
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(GetPullRequestError::PullRequestIdRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetPullRequestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetPullRequestError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetPullRequestError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetPullRequestError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetPullRequestError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetPullRequestError::InvalidPullRequestId(ref cause) => write!(f, "{}", cause),
GetPullRequestError::PullRequestDoesNotExist(ref cause) => write!(f, "{}", cause),
GetPullRequestError::PullRequestIdRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetPullRequestError {}
#[derive(Debug, PartialEq)]
pub enum GetPullRequestApprovalStatesError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidPullRequestId(String),
InvalidRevisionId(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
RevisionIdRequired(String),
}
impl GetPullRequestApprovalStatesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetPullRequestApprovalStatesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
GetPullRequestApprovalStatesError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
GetPullRequestApprovalStatesError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
GetPullRequestApprovalStatesError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
GetPullRequestApprovalStatesError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
GetPullRequestApprovalStatesError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
GetPullRequestApprovalStatesError::InvalidPullRequestId(err.msg),
)
}
"InvalidRevisionIdException" => {
return RusotoError::Service(
GetPullRequestApprovalStatesError::InvalidRevisionId(err.msg),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
GetPullRequestApprovalStatesError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
GetPullRequestApprovalStatesError::PullRequestIdRequired(err.msg),
)
}
"RevisionIdRequiredException" => {
return RusotoError::Service(
GetPullRequestApprovalStatesError::RevisionIdRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetPullRequestApprovalStatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetPullRequestApprovalStatesError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestApprovalStatesError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestApprovalStatesError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestApprovalStatesError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestApprovalStatesError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestApprovalStatesError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestApprovalStatesError::InvalidRevisionId(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestApprovalStatesError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestApprovalStatesError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestApprovalStatesError::RevisionIdRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetPullRequestApprovalStatesError {}
#[derive(Debug, PartialEq)]
pub enum GetPullRequestOverrideStateError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidPullRequestId(String),
InvalidRevisionId(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
RevisionIdRequired(String),
}
impl GetPullRequestOverrideStateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetPullRequestOverrideStateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
GetPullRequestOverrideStateError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
GetPullRequestOverrideStateError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
GetPullRequestOverrideStateError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
GetPullRequestOverrideStateError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
GetPullRequestOverrideStateError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
GetPullRequestOverrideStateError::InvalidPullRequestId(err.msg),
)
}
"InvalidRevisionIdException" => {
return RusotoError::Service(
GetPullRequestOverrideStateError::InvalidRevisionId(err.msg),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
GetPullRequestOverrideStateError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
GetPullRequestOverrideStateError::PullRequestIdRequired(err.msg),
)
}
"RevisionIdRequiredException" => {
return RusotoError::Service(
GetPullRequestOverrideStateError::RevisionIdRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetPullRequestOverrideStateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetPullRequestOverrideStateError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestOverrideStateError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestOverrideStateError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestOverrideStateError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestOverrideStateError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestOverrideStateError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestOverrideStateError::InvalidRevisionId(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestOverrideStateError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestOverrideStateError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
GetPullRequestOverrideStateError::RevisionIdRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetPullRequestOverrideStateError {}
#[derive(Debug, PartialEq)]
pub enum GetRepositoryError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl GetRepositoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetRepositoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
GetRepositoryError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(GetRepositoryError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetRepositoryError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetRepositoryError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(GetRepositoryError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(GetRepositoryError::InvalidRepositoryName(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(GetRepositoryError::RepositoryDoesNotExist(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(GetRepositoryError::RepositoryNameRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRepositoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRepositoryError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
GetRepositoryError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
GetRepositoryError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetRepositoryError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetRepositoryError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
GetRepositoryError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
GetRepositoryError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
GetRepositoryError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRepositoryError {}
#[derive(Debug, PartialEq)]
pub enum GetRepositoryTriggersError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl GetRepositoryTriggersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetRepositoryTriggersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
GetRepositoryTriggersError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
GetRepositoryTriggersError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(GetRepositoryTriggersError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(GetRepositoryTriggersError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
GetRepositoryTriggersError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(GetRepositoryTriggersError::InvalidRepositoryName(
err.msg,
))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
GetRepositoryTriggersError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
GetRepositoryTriggersError::RepositoryNameRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetRepositoryTriggersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetRepositoryTriggersError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
GetRepositoryTriggersError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
GetRepositoryTriggersError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
GetRepositoryTriggersError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
GetRepositoryTriggersError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
GetRepositoryTriggersError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
GetRepositoryTriggersError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
GetRepositoryTriggersError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetRepositoryTriggersError {}
#[derive(Debug, PartialEq)]
pub enum ListApprovalRuleTemplatesError {
InvalidContinuationToken(String),
InvalidMaxResults(String),
}
impl ListApprovalRuleTemplatesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListApprovalRuleTemplatesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidContinuationTokenException" => {
return RusotoError::Service(
ListApprovalRuleTemplatesError::InvalidContinuationToken(err.msg),
)
}
"InvalidMaxResultsException" => {
return RusotoError::Service(ListApprovalRuleTemplatesError::InvalidMaxResults(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListApprovalRuleTemplatesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListApprovalRuleTemplatesError::InvalidContinuationToken(ref cause) => {
write!(f, "{}", cause)
}
ListApprovalRuleTemplatesError::InvalidMaxResults(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListApprovalRuleTemplatesError {}
#[derive(Debug, PartialEq)]
pub enum ListAssociatedApprovalRuleTemplatesForRepositoryError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidContinuationToken(String),
InvalidMaxResults(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl ListAssociatedApprovalRuleTemplatesForRepositoryError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListAssociatedApprovalRuleTemplatesForRepositoryError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => return RusotoError::Service(ListAssociatedApprovalRuleTemplatesForRepositoryError::EncryptionIntegrityChecksFailed(err.msg)),
"EncryptionKeyAccessDeniedException" => return RusotoError::Service(ListAssociatedApprovalRuleTemplatesForRepositoryError::EncryptionKeyAccessDenied(err.msg)),
"EncryptionKeyDisabledException" => return RusotoError::Service(ListAssociatedApprovalRuleTemplatesForRepositoryError::EncryptionKeyDisabled(err.msg)),
"EncryptionKeyNotFoundException" => return RusotoError::Service(ListAssociatedApprovalRuleTemplatesForRepositoryError::EncryptionKeyNotFound(err.msg)),
"EncryptionKeyUnavailableException" => return RusotoError::Service(ListAssociatedApprovalRuleTemplatesForRepositoryError::EncryptionKeyUnavailable(err.msg)),
"InvalidContinuationTokenException" => return RusotoError::Service(ListAssociatedApprovalRuleTemplatesForRepositoryError::InvalidContinuationToken(err.msg)),
"InvalidMaxResultsException" => return RusotoError::Service(ListAssociatedApprovalRuleTemplatesForRepositoryError::InvalidMaxResults(err.msg)),
"InvalidRepositoryNameException" => return RusotoError::Service(ListAssociatedApprovalRuleTemplatesForRepositoryError::InvalidRepositoryName(err.msg)),
"RepositoryDoesNotExistException" => return RusotoError::Service(ListAssociatedApprovalRuleTemplatesForRepositoryError::RepositoryDoesNotExist(err.msg)),
"RepositoryNameRequiredException" => return RusotoError::Service(ListAssociatedApprovalRuleTemplatesForRepositoryError::RepositoryNameRequired(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAssociatedApprovalRuleTemplatesForRepositoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAssociatedApprovalRuleTemplatesForRepositoryError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
ListAssociatedApprovalRuleTemplatesForRepositoryError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
ListAssociatedApprovalRuleTemplatesForRepositoryError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
ListAssociatedApprovalRuleTemplatesForRepositoryError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
ListAssociatedApprovalRuleTemplatesForRepositoryError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
ListAssociatedApprovalRuleTemplatesForRepositoryError::InvalidContinuationToken(ref cause) => write!(f, "{}", cause),
ListAssociatedApprovalRuleTemplatesForRepositoryError::InvalidMaxResults(ref cause) => write!(f, "{}", cause),
ListAssociatedApprovalRuleTemplatesForRepositoryError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
ListAssociatedApprovalRuleTemplatesForRepositoryError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
ListAssociatedApprovalRuleTemplatesForRepositoryError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause)
}
}
}
impl Error for ListAssociatedApprovalRuleTemplatesForRepositoryError {}
#[derive(Debug, PartialEq)]
pub enum ListBranchesError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidContinuationToken(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl ListBranchesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListBranchesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
ListBranchesError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(ListBranchesError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(ListBranchesError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(ListBranchesError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(ListBranchesError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidContinuationTokenException" => {
return RusotoError::Service(ListBranchesError::InvalidContinuationToken(
err.msg,
))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(ListBranchesError::InvalidRepositoryName(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(ListBranchesError::RepositoryDoesNotExist(err.msg))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(ListBranchesError::RepositoryNameRequired(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::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
ListBranchesError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
ListBranchesError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
ListBranchesError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
ListBranchesError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
ListBranchesError::InvalidContinuationToken(ref cause) => write!(f, "{}", cause),
ListBranchesError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
ListBranchesError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
ListBranchesError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListBranchesError {}
#[derive(Debug, PartialEq)]
pub enum ListPullRequestsError {
AuthorDoesNotExist(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidAuthorArn(String),
InvalidContinuationToken(String),
InvalidMaxResults(String),
InvalidPullRequestStatus(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl ListPullRequestsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPullRequestsError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"AuthorDoesNotExistException" => {
return RusotoError::Service(ListPullRequestsError::AuthorDoesNotExist(err.msg))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
ListPullRequestsError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(ListPullRequestsError::EncryptionKeyAccessDenied(
err.msg,
))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(ListPullRequestsError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(ListPullRequestsError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(ListPullRequestsError::EncryptionKeyUnavailable(
err.msg,
))
}
"InvalidAuthorArnException" => {
return RusotoError::Service(ListPullRequestsError::InvalidAuthorArn(err.msg))
}
"InvalidContinuationTokenException" => {
return RusotoError::Service(ListPullRequestsError::InvalidContinuationToken(
err.msg,
))
}
"InvalidMaxResultsException" => {
return RusotoError::Service(ListPullRequestsError::InvalidMaxResults(err.msg))
}
"InvalidPullRequestStatusException" => {
return RusotoError::Service(ListPullRequestsError::InvalidPullRequestStatus(
err.msg,
))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(ListPullRequestsError::InvalidRepositoryName(
err.msg,
))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(ListPullRequestsError::RepositoryDoesNotExist(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(ListPullRequestsError::RepositoryNameRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPullRequestsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPullRequestsError::AuthorDoesNotExist(ref cause) => write!(f, "{}", cause),
ListPullRequestsError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
ListPullRequestsError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
ListPullRequestsError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
ListPullRequestsError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
ListPullRequestsError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
ListPullRequestsError::InvalidAuthorArn(ref cause) => write!(f, "{}", cause),
ListPullRequestsError::InvalidContinuationToken(ref cause) => write!(f, "{}", cause),
ListPullRequestsError::InvalidMaxResults(ref cause) => write!(f, "{}", cause),
ListPullRequestsError::InvalidPullRequestStatus(ref cause) => write!(f, "{}", cause),
ListPullRequestsError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
ListPullRequestsError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
ListPullRequestsError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPullRequestsError {}
#[derive(Debug, PartialEq)]
pub enum ListRepositoriesError {
InvalidContinuationToken(String),
InvalidOrder(String),
InvalidSortBy(String),
}
impl ListRepositoriesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListRepositoriesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidContinuationTokenException" => {
return RusotoError::Service(ListRepositoriesError::InvalidContinuationToken(
err.msg,
))
}
"InvalidOrderException" => {
return RusotoError::Service(ListRepositoriesError::InvalidOrder(err.msg))
}
"InvalidSortByException" => {
return RusotoError::Service(ListRepositoriesError::InvalidSortBy(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRepositoriesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRepositoriesError::InvalidContinuationToken(ref cause) => write!(f, "{}", cause),
ListRepositoriesError::InvalidOrder(ref cause) => write!(f, "{}", cause),
ListRepositoriesError::InvalidSortBy(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListRepositoriesError {}
#[derive(Debug, PartialEq)]
pub enum ListRepositoriesForApprovalRuleTemplateError {
ApprovalRuleTemplateDoesNotExist(String),
ApprovalRuleTemplateNameRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidApprovalRuleTemplateName(String),
InvalidContinuationToken(String),
InvalidMaxResults(String),
}
impl ListRepositoriesForApprovalRuleTemplateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListRepositoriesForApprovalRuleTemplateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleTemplateDoesNotExistException" => return RusotoError::Service(
ListRepositoriesForApprovalRuleTemplateError::ApprovalRuleTemplateDoesNotExist(
err.msg,
),
),
"ApprovalRuleTemplateNameRequiredException" => return RusotoError::Service(
ListRepositoriesForApprovalRuleTemplateError::ApprovalRuleTemplateNameRequired(
err.msg,
),
),
"EncryptionIntegrityChecksFailedException" => return RusotoError::Service(
ListRepositoriesForApprovalRuleTemplateError::EncryptionIntegrityChecksFailed(
err.msg,
),
),
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
ListRepositoriesForApprovalRuleTemplateError::EncryptionKeyAccessDenied(
err.msg,
),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
ListRepositoriesForApprovalRuleTemplateError::EncryptionKeyDisabled(
err.msg,
),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
ListRepositoriesForApprovalRuleTemplateError::EncryptionKeyNotFound(
err.msg,
),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
ListRepositoriesForApprovalRuleTemplateError::EncryptionKeyUnavailable(
err.msg,
),
)
}
"InvalidApprovalRuleTemplateNameException" => return RusotoError::Service(
ListRepositoriesForApprovalRuleTemplateError::InvalidApprovalRuleTemplateName(
err.msg,
),
),
"InvalidContinuationTokenException" => {
return RusotoError::Service(
ListRepositoriesForApprovalRuleTemplateError::InvalidContinuationToken(
err.msg,
),
)
}
"InvalidMaxResultsException" => {
return RusotoError::Service(
ListRepositoriesForApprovalRuleTemplateError::InvalidMaxResults(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListRepositoriesForApprovalRuleTemplateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListRepositoriesForApprovalRuleTemplateError::ApprovalRuleTemplateDoesNotExist(
ref cause,
) => write!(f, "{}", cause),
ListRepositoriesForApprovalRuleTemplateError::ApprovalRuleTemplateNameRequired(
ref cause,
) => write!(f, "{}", cause),
ListRepositoriesForApprovalRuleTemplateError::EncryptionIntegrityChecksFailed(
ref cause,
) => write!(f, "{}", cause),
ListRepositoriesForApprovalRuleTemplateError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
ListRepositoriesForApprovalRuleTemplateError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
ListRepositoriesForApprovalRuleTemplateError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListRepositoriesForApprovalRuleTemplateError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
ListRepositoriesForApprovalRuleTemplateError::InvalidApprovalRuleTemplateName(
ref cause,
) => write!(f, "{}", cause),
ListRepositoriesForApprovalRuleTemplateError::InvalidContinuationToken(ref cause) => {
write!(f, "{}", cause)
}
ListRepositoriesForApprovalRuleTemplateError::InvalidMaxResults(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListRepositoriesForApprovalRuleTemplateError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
InvalidRepositoryName(String),
InvalidResourceArn(String),
RepositoryDoesNotExist(String),
ResourceArnRequired(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidRepositoryNameException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidRepositoryName(
err.msg,
))
}
"InvalidResourceArnException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidResourceArn(
err.msg,
))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(ListTagsForResourceError::RepositoryDoesNotExist(
err.msg,
))
}
"ResourceArnRequiredException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceArnRequired(
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::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidResourceArn(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceArnRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum MergeBranchesByFastForwardError {
BranchDoesNotExist(String),
BranchNameIsTagName(String),
BranchNameRequired(String),
CommitDoesNotExist(String),
CommitRequired(String),
ConcurrentReferenceUpdate(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidBranchName(String),
InvalidCommit(String),
InvalidRepositoryName(String),
InvalidTargetBranch(String),
ManualMergeRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
TipsDivergenceExceeded(String),
}
impl MergeBranchesByFastForwardError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<MergeBranchesByFastForwardError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BranchDoesNotExistException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::BranchDoesNotExist(err.msg),
)
}
"BranchNameIsTagNameException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::BranchNameIsTagName(err.msg),
)
}
"BranchNameRequiredException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::BranchNameRequired(err.msg),
)
}
"CommitDoesNotExistException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::CommitDoesNotExist(err.msg),
)
}
"CommitRequiredException" => {
return RusotoError::Service(MergeBranchesByFastForwardError::CommitRequired(
err.msg,
))
}
"ConcurrentReferenceUpdateException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::ConcurrentReferenceUpdate(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidBranchNameException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::InvalidBranchName(err.msg),
)
}
"InvalidCommitException" => {
return RusotoError::Service(MergeBranchesByFastForwardError::InvalidCommit(
err.msg,
))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::InvalidRepositoryName(err.msg),
)
}
"InvalidTargetBranchException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::InvalidTargetBranch(err.msg),
)
}
"ManualMergeRequiredException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::ManualMergeRequired(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::RepositoryNameRequired(err.msg),
)
}
"TipsDivergenceExceededException" => {
return RusotoError::Service(
MergeBranchesByFastForwardError::TipsDivergenceExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for MergeBranchesByFastForwardError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
MergeBranchesByFastForwardError::BranchDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::BranchNameIsTagName(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::BranchNameRequired(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::CommitDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::CommitRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesByFastForwardError::ConcurrentReferenceUpdate(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::InvalidBranchName(ref cause) => write!(f, "{}", cause),
MergeBranchesByFastForwardError::InvalidCommit(ref cause) => write!(f, "{}", cause),
MergeBranchesByFastForwardError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::InvalidTargetBranch(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::ManualMergeRequired(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByFastForwardError::TipsDivergenceExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for MergeBranchesByFastForwardError {}
#[derive(Debug, PartialEq)]
pub enum MergeBranchesBySquashError {
BranchDoesNotExist(String),
BranchNameIsTagName(String),
BranchNameRequired(String),
CommitDoesNotExist(String),
CommitMessageLengthExceeded(String),
CommitRequired(String),
ConcurrentReferenceUpdate(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FileContentSizeLimitExceeded(String),
FileModeRequired(String),
FolderContentSizeLimitExceeded(String),
InvalidBranchName(String),
InvalidCommit(String),
InvalidConflictDetailLevel(String),
InvalidConflictResolution(String),
InvalidConflictResolutionStrategy(String),
InvalidEmail(String),
InvalidFileMode(String),
InvalidPath(String),
InvalidReplacementContent(String),
InvalidReplacementType(String),
InvalidRepositoryName(String),
InvalidTargetBranch(String),
ManualMergeRequired(String),
MaximumConflictResolutionEntriesExceeded(String),
MaximumFileContentToLoadExceeded(String),
MaximumItemsToCompareExceeded(String),
MultipleConflictResolutionEntries(String),
NameLengthExceeded(String),
PathRequired(String),
ReplacementContentRequired(String),
ReplacementTypeRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
TipsDivergenceExceeded(String),
}
impl MergeBranchesBySquashError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<MergeBranchesBySquashError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BranchDoesNotExistException" => {
return RusotoError::Service(MergeBranchesBySquashError::BranchDoesNotExist(
err.msg,
))
}
"BranchNameIsTagNameException" => {
return RusotoError::Service(MergeBranchesBySquashError::BranchNameIsTagName(
err.msg,
))
}
"BranchNameRequiredException" => {
return RusotoError::Service(MergeBranchesBySquashError::BranchNameRequired(
err.msg,
))
}
"CommitDoesNotExistException" => {
return RusotoError::Service(MergeBranchesBySquashError::CommitDoesNotExist(
err.msg,
))
}
"CommitMessageLengthExceededException" => {
return RusotoError::Service(
MergeBranchesBySquashError::CommitMessageLengthExceeded(err.msg),
)
}
"CommitRequiredException" => {
return RusotoError::Service(MergeBranchesBySquashError::CommitRequired(
err.msg,
))
}
"ConcurrentReferenceUpdateException" => {
return RusotoError::Service(
MergeBranchesBySquashError::ConcurrentReferenceUpdate(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
MergeBranchesBySquashError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
MergeBranchesBySquashError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(MergeBranchesBySquashError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(MergeBranchesBySquashError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
MergeBranchesBySquashError::EncryptionKeyUnavailable(err.msg),
)
}
"FileContentSizeLimitExceededException" => {
return RusotoError::Service(
MergeBranchesBySquashError::FileContentSizeLimitExceeded(err.msg),
)
}
"FileModeRequiredException" => {
return RusotoError::Service(MergeBranchesBySquashError::FileModeRequired(
err.msg,
))
}
"FolderContentSizeLimitExceededException" => {
return RusotoError::Service(
MergeBranchesBySquashError::FolderContentSizeLimitExceeded(err.msg),
)
}
"InvalidBranchNameException" => {
return RusotoError::Service(MergeBranchesBySquashError::InvalidBranchName(
err.msg,
))
}
"InvalidCommitException" => {
return RusotoError::Service(MergeBranchesBySquashError::InvalidCommit(err.msg))
}
"InvalidConflictDetailLevelException" => {
return RusotoError::Service(
MergeBranchesBySquashError::InvalidConflictDetailLevel(err.msg),
)
}
"InvalidConflictResolutionException" => {
return RusotoError::Service(
MergeBranchesBySquashError::InvalidConflictResolution(err.msg),
)
}
"InvalidConflictResolutionStrategyException" => {
return RusotoError::Service(
MergeBranchesBySquashError::InvalidConflictResolutionStrategy(err.msg),
)
}
"InvalidEmailException" => {
return RusotoError::Service(MergeBranchesBySquashError::InvalidEmail(err.msg))
}
"InvalidFileModeException" => {
return RusotoError::Service(MergeBranchesBySquashError::InvalidFileMode(
err.msg,
))
}
"InvalidPathException" => {
return RusotoError::Service(MergeBranchesBySquashError::InvalidPath(err.msg))
}
"InvalidReplacementContentException" => {
return RusotoError::Service(
MergeBranchesBySquashError::InvalidReplacementContent(err.msg),
)
}
"InvalidReplacementTypeException" => {
return RusotoError::Service(
MergeBranchesBySquashError::InvalidReplacementType(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(MergeBranchesBySquashError::InvalidRepositoryName(
err.msg,
))
}
"InvalidTargetBranchException" => {
return RusotoError::Service(MergeBranchesBySquashError::InvalidTargetBranch(
err.msg,
))
}
"ManualMergeRequiredException" => {
return RusotoError::Service(MergeBranchesBySquashError::ManualMergeRequired(
err.msg,
))
}
"MaximumConflictResolutionEntriesExceededException" => {
return RusotoError::Service(
MergeBranchesBySquashError::MaximumConflictResolutionEntriesExceeded(
err.msg,
),
)
}
"MaximumFileContentToLoadExceededException" => {
return RusotoError::Service(
MergeBranchesBySquashError::MaximumFileContentToLoadExceeded(err.msg),
)
}
"MaximumItemsToCompareExceededException" => {
return RusotoError::Service(
MergeBranchesBySquashError::MaximumItemsToCompareExceeded(err.msg),
)
}
"MultipleConflictResolutionEntriesException" => {
return RusotoError::Service(
MergeBranchesBySquashError::MultipleConflictResolutionEntries(err.msg),
)
}
"NameLengthExceededException" => {
return RusotoError::Service(MergeBranchesBySquashError::NameLengthExceeded(
err.msg,
))
}
"PathRequiredException" => {
return RusotoError::Service(MergeBranchesBySquashError::PathRequired(err.msg))
}
"ReplacementContentRequiredException" => {
return RusotoError::Service(
MergeBranchesBySquashError::ReplacementContentRequired(err.msg),
)
}
"ReplacementTypeRequiredException" => {
return RusotoError::Service(
MergeBranchesBySquashError::ReplacementTypeRequired(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
MergeBranchesBySquashError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
MergeBranchesBySquashError::RepositoryNameRequired(err.msg),
)
}
"TipsDivergenceExceededException" => {
return RusotoError::Service(
MergeBranchesBySquashError::TipsDivergenceExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for MergeBranchesBySquashError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
MergeBranchesBySquashError::BranchDoesNotExist(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::BranchNameIsTagName(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::BranchNameRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::CommitMessageLengthExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::CommitRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::ConcurrentReferenceUpdate(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::FileContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::FileModeRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::FolderContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::InvalidBranchName(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::InvalidCommit(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::InvalidConflictDetailLevel(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::InvalidConflictResolution(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::InvalidConflictResolutionStrategy(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::InvalidEmail(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::InvalidFileMode(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::InvalidPath(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::InvalidReplacementContent(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::InvalidReplacementType(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::InvalidTargetBranch(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::ManualMergeRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::MaximumConflictResolutionEntriesExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::MaximumFileContentToLoadExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::MaximumItemsToCompareExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::MultipleConflictResolutionEntries(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::NameLengthExceeded(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::PathRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::ReplacementContentRequired(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::ReplacementTypeRequired(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesBySquashError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesBySquashError::TipsDivergenceExceeded(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for MergeBranchesBySquashError {}
#[derive(Debug, PartialEq)]
pub enum MergeBranchesByThreeWayError {
BranchDoesNotExist(String),
BranchNameIsTagName(String),
BranchNameRequired(String),
CommitDoesNotExist(String),
CommitMessageLengthExceeded(String),
CommitRequired(String),
ConcurrentReferenceUpdate(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FileContentSizeLimitExceeded(String),
FileModeRequired(String),
FolderContentSizeLimitExceeded(String),
InvalidBranchName(String),
InvalidCommit(String),
InvalidConflictDetailLevel(String),
InvalidConflictResolution(String),
InvalidConflictResolutionStrategy(String),
InvalidEmail(String),
InvalidFileMode(String),
InvalidPath(String),
InvalidReplacementContent(String),
InvalidReplacementType(String),
InvalidRepositoryName(String),
InvalidTargetBranch(String),
ManualMergeRequired(String),
MaximumConflictResolutionEntriesExceeded(String),
MaximumFileContentToLoadExceeded(String),
MaximumItemsToCompareExceeded(String),
MultipleConflictResolutionEntries(String),
NameLengthExceeded(String),
PathRequired(String),
ReplacementContentRequired(String),
ReplacementTypeRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
TipsDivergenceExceeded(String),
}
impl MergeBranchesByThreeWayError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<MergeBranchesByThreeWayError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BranchDoesNotExistException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::BranchDoesNotExist(
err.msg,
))
}
"BranchNameIsTagNameException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::BranchNameIsTagName(
err.msg,
))
}
"BranchNameRequiredException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::BranchNameRequired(
err.msg,
))
}
"CommitDoesNotExistException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::CommitDoesNotExist(
err.msg,
))
}
"CommitMessageLengthExceededException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::CommitMessageLengthExceeded(err.msg),
)
}
"CommitRequiredException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::CommitRequired(
err.msg,
))
}
"ConcurrentReferenceUpdateException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::ConcurrentReferenceUpdate(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::EncryptionKeyUnavailable(err.msg),
)
}
"FileContentSizeLimitExceededException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::FileContentSizeLimitExceeded(err.msg),
)
}
"FileModeRequiredException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::FileModeRequired(
err.msg,
))
}
"FolderContentSizeLimitExceededException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::FolderContentSizeLimitExceeded(err.msg),
)
}
"InvalidBranchNameException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::InvalidBranchName(
err.msg,
))
}
"InvalidCommitException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::InvalidCommit(
err.msg,
))
}
"InvalidConflictDetailLevelException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::InvalidConflictDetailLevel(err.msg),
)
}
"InvalidConflictResolutionException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::InvalidConflictResolution(err.msg),
)
}
"InvalidConflictResolutionStrategyException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::InvalidConflictResolutionStrategy(err.msg),
)
}
"InvalidEmailException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::InvalidEmail(
err.msg,
))
}
"InvalidFileModeException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::InvalidFileMode(
err.msg,
))
}
"InvalidPathException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::InvalidPath(err.msg))
}
"InvalidReplacementContentException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::InvalidReplacementContent(err.msg),
)
}
"InvalidReplacementTypeException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::InvalidReplacementType(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::InvalidRepositoryName(err.msg),
)
}
"InvalidTargetBranchException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::InvalidTargetBranch(
err.msg,
))
}
"ManualMergeRequiredException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::ManualMergeRequired(
err.msg,
))
}
"MaximumConflictResolutionEntriesExceededException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::MaximumConflictResolutionEntriesExceeded(
err.msg,
),
)
}
"MaximumFileContentToLoadExceededException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::MaximumFileContentToLoadExceeded(err.msg),
)
}
"MaximumItemsToCompareExceededException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::MaximumItemsToCompareExceeded(err.msg),
)
}
"MultipleConflictResolutionEntriesException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::MultipleConflictResolutionEntries(err.msg),
)
}
"NameLengthExceededException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::NameLengthExceeded(
err.msg,
))
}
"PathRequiredException" => {
return RusotoError::Service(MergeBranchesByThreeWayError::PathRequired(
err.msg,
))
}
"ReplacementContentRequiredException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::ReplacementContentRequired(err.msg),
)
}
"ReplacementTypeRequiredException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::ReplacementTypeRequired(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::RepositoryNameRequired(err.msg),
)
}
"TipsDivergenceExceededException" => {
return RusotoError::Service(
MergeBranchesByThreeWayError::TipsDivergenceExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for MergeBranchesByThreeWayError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
MergeBranchesByThreeWayError::BranchDoesNotExist(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::BranchNameIsTagName(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::BranchNameRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::CommitMessageLengthExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::CommitRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::ConcurrentReferenceUpdate(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::FileContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::FileModeRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::FolderContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::InvalidBranchName(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::InvalidCommit(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::InvalidConflictDetailLevel(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::InvalidConflictResolution(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::InvalidConflictResolutionStrategy(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::InvalidEmail(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::InvalidFileMode(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::InvalidPath(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::InvalidReplacementContent(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::InvalidReplacementType(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::InvalidTargetBranch(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::ManualMergeRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::MaximumConflictResolutionEntriesExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::MaximumFileContentToLoadExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::MaximumItemsToCompareExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::MultipleConflictResolutionEntries(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::NameLengthExceeded(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::PathRequired(ref cause) => write!(f, "{}", cause),
MergeBranchesByThreeWayError::ReplacementContentRequired(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::ReplacementTypeRequired(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
MergeBranchesByThreeWayError::TipsDivergenceExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for MergeBranchesByThreeWayError {}
#[derive(Debug, PartialEq)]
pub enum MergePullRequestByFastForwardError {
ConcurrentReferenceUpdate(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidCommitId(String),
InvalidPullRequestId(String),
InvalidRepositoryName(String),
ManualMergeRequired(String),
PullRequestAlreadyClosed(String),
PullRequestApprovalRulesNotSatisfied(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
ReferenceDoesNotExist(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
RepositoryNotAssociatedWithPullRequest(String),
TipOfSourceReferenceIsDifferent(String),
}
impl MergePullRequestByFastForwardError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<MergePullRequestByFastForwardError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ConcurrentReferenceUpdateException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::ConcurrentReferenceUpdate(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::EncryptionIntegrityChecksFailed(
err.msg,
),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidCommitIdException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::InvalidCommitId(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::InvalidPullRequestId(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::InvalidRepositoryName(err.msg),
)
}
"ManualMergeRequiredException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::ManualMergeRequired(err.msg),
)
}
"PullRequestAlreadyClosedException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::PullRequestAlreadyClosed(err.msg),
)
}
"PullRequestApprovalRulesNotSatisfiedException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::PullRequestApprovalRulesNotSatisfied(
err.msg,
),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::PullRequestIdRequired(err.msg),
)
}
"ReferenceDoesNotExistException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::ReferenceDoesNotExist(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::RepositoryNameRequired(err.msg),
)
}
"RepositoryNotAssociatedWithPullRequestException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::RepositoryNotAssociatedWithPullRequest(
err.msg,
),
)
}
"TipOfSourceReferenceIsDifferentException" => {
return RusotoError::Service(
MergePullRequestByFastForwardError::TipOfSourceReferenceIsDifferent(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for MergePullRequestByFastForwardError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
MergePullRequestByFastForwardError::ConcurrentReferenceUpdate(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::InvalidCommitId(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::ManualMergeRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::PullRequestAlreadyClosed(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::PullRequestApprovalRulesNotSatisfied(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::ReferenceDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByFastForwardError::RepositoryNotAssociatedWithPullRequest(
ref cause,
) => write!(f, "{}", cause),
MergePullRequestByFastForwardError::TipOfSourceReferenceIsDifferent(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for MergePullRequestByFastForwardError {}
#[derive(Debug, PartialEq)]
pub enum MergePullRequestBySquashError {
CommitMessageLengthExceeded(String),
ConcurrentReferenceUpdate(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FileContentSizeLimitExceeded(String),
FolderContentSizeLimitExceeded(String),
InvalidCommitId(String),
InvalidConflictDetailLevel(String),
InvalidConflictResolution(String),
InvalidConflictResolutionStrategy(String),
InvalidEmail(String),
InvalidFileMode(String),
InvalidPath(String),
InvalidPullRequestId(String),
InvalidReplacementContent(String),
InvalidReplacementType(String),
InvalidRepositoryName(String),
ManualMergeRequired(String),
MaximumConflictResolutionEntriesExceeded(String),
MaximumFileContentToLoadExceeded(String),
MaximumItemsToCompareExceeded(String),
MultipleConflictResolutionEntries(String),
NameLengthExceeded(String),
PathRequired(String),
PullRequestAlreadyClosed(String),
PullRequestApprovalRulesNotSatisfied(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
ReplacementContentRequired(String),
ReplacementTypeRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
RepositoryNotAssociatedWithPullRequest(String),
TipOfSourceReferenceIsDifferent(String),
TipsDivergenceExceeded(String),
}
impl MergePullRequestBySquashError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<MergePullRequestBySquashError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitMessageLengthExceededException" => {
return RusotoError::Service(
MergePullRequestBySquashError::CommitMessageLengthExceeded(err.msg),
)
}
"ConcurrentReferenceUpdateException" => {
return RusotoError::Service(
MergePullRequestBySquashError::ConcurrentReferenceUpdate(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
MergePullRequestBySquashError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
MergePullRequestBySquashError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
MergePullRequestBySquashError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
MergePullRequestBySquashError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
MergePullRequestBySquashError::EncryptionKeyUnavailable(err.msg),
)
}
"FileContentSizeLimitExceededException" => {
return RusotoError::Service(
MergePullRequestBySquashError::FileContentSizeLimitExceeded(err.msg),
)
}
"FolderContentSizeLimitExceededException" => {
return RusotoError::Service(
MergePullRequestBySquashError::FolderContentSizeLimitExceeded(err.msg),
)
}
"InvalidCommitIdException" => {
return RusotoError::Service(MergePullRequestBySquashError::InvalidCommitId(
err.msg,
))
}
"InvalidConflictDetailLevelException" => {
return RusotoError::Service(
MergePullRequestBySquashError::InvalidConflictDetailLevel(err.msg),
)
}
"InvalidConflictResolutionException" => {
return RusotoError::Service(
MergePullRequestBySquashError::InvalidConflictResolution(err.msg),
)
}
"InvalidConflictResolutionStrategyException" => {
return RusotoError::Service(
MergePullRequestBySquashError::InvalidConflictResolutionStrategy(err.msg),
)
}
"InvalidEmailException" => {
return RusotoError::Service(MergePullRequestBySquashError::InvalidEmail(
err.msg,
))
}
"InvalidFileModeException" => {
return RusotoError::Service(MergePullRequestBySquashError::InvalidFileMode(
err.msg,
))
}
"InvalidPathException" => {
return RusotoError::Service(MergePullRequestBySquashError::InvalidPath(
err.msg,
))
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
MergePullRequestBySquashError::InvalidPullRequestId(err.msg),
)
}
"InvalidReplacementContentException" => {
return RusotoError::Service(
MergePullRequestBySquashError::InvalidReplacementContent(err.msg),
)
}
"InvalidReplacementTypeException" => {
return RusotoError::Service(
MergePullRequestBySquashError::InvalidReplacementType(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
MergePullRequestBySquashError::InvalidRepositoryName(err.msg),
)
}
"ManualMergeRequiredException" => {
return RusotoError::Service(
MergePullRequestBySquashError::ManualMergeRequired(err.msg),
)
}
"MaximumConflictResolutionEntriesExceededException" => {
return RusotoError::Service(
MergePullRequestBySquashError::MaximumConflictResolutionEntriesExceeded(
err.msg,
),
)
}
"MaximumFileContentToLoadExceededException" => {
return RusotoError::Service(
MergePullRequestBySquashError::MaximumFileContentToLoadExceeded(err.msg),
)
}
"MaximumItemsToCompareExceededException" => {
return RusotoError::Service(
MergePullRequestBySquashError::MaximumItemsToCompareExceeded(err.msg),
)
}
"MultipleConflictResolutionEntriesException" => {
return RusotoError::Service(
MergePullRequestBySquashError::MultipleConflictResolutionEntries(err.msg),
)
}
"NameLengthExceededException" => {
return RusotoError::Service(MergePullRequestBySquashError::NameLengthExceeded(
err.msg,
))
}
"PathRequiredException" => {
return RusotoError::Service(MergePullRequestBySquashError::PathRequired(
err.msg,
))
}
"PullRequestAlreadyClosedException" => {
return RusotoError::Service(
MergePullRequestBySquashError::PullRequestAlreadyClosed(err.msg),
)
}
"PullRequestApprovalRulesNotSatisfiedException" => {
return RusotoError::Service(
MergePullRequestBySquashError::PullRequestApprovalRulesNotSatisfied(
err.msg,
),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
MergePullRequestBySquashError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
MergePullRequestBySquashError::PullRequestIdRequired(err.msg),
)
}
"ReplacementContentRequiredException" => {
return RusotoError::Service(
MergePullRequestBySquashError::ReplacementContentRequired(err.msg),
)
}
"ReplacementTypeRequiredException" => {
return RusotoError::Service(
MergePullRequestBySquashError::ReplacementTypeRequired(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
MergePullRequestBySquashError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
MergePullRequestBySquashError::RepositoryNameRequired(err.msg),
)
}
"RepositoryNotAssociatedWithPullRequestException" => {
return RusotoError::Service(
MergePullRequestBySquashError::RepositoryNotAssociatedWithPullRequest(
err.msg,
),
)
}
"TipOfSourceReferenceIsDifferentException" => {
return RusotoError::Service(
MergePullRequestBySquashError::TipOfSourceReferenceIsDifferent(err.msg),
)
}
"TipsDivergenceExceededException" => {
return RusotoError::Service(
MergePullRequestBySquashError::TipsDivergenceExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for MergePullRequestBySquashError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
MergePullRequestBySquashError::CommitMessageLengthExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::ConcurrentReferenceUpdate(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::FileContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::FolderContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::InvalidCommitId(ref cause) => write!(f, "{}", cause),
MergePullRequestBySquashError::InvalidConflictDetailLevel(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::InvalidConflictResolution(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::InvalidConflictResolutionStrategy(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::InvalidEmail(ref cause) => write!(f, "{}", cause),
MergePullRequestBySquashError::InvalidFileMode(ref cause) => write!(f, "{}", cause),
MergePullRequestBySquashError::InvalidPath(ref cause) => write!(f, "{}", cause),
MergePullRequestBySquashError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::InvalidReplacementContent(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::InvalidReplacementType(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::ManualMergeRequired(ref cause) => write!(f, "{}", cause),
MergePullRequestBySquashError::MaximumConflictResolutionEntriesExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::MaximumFileContentToLoadExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::MaximumItemsToCompareExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::MultipleConflictResolutionEntries(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::NameLengthExceeded(ref cause) => write!(f, "{}", cause),
MergePullRequestBySquashError::PathRequired(ref cause) => write!(f, "{}", cause),
MergePullRequestBySquashError::PullRequestAlreadyClosed(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::PullRequestApprovalRulesNotSatisfied(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::ReplacementContentRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::ReplacementTypeRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::RepositoryNotAssociatedWithPullRequest(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::TipOfSourceReferenceIsDifferent(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestBySquashError::TipsDivergenceExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for MergePullRequestBySquashError {}
#[derive(Debug, PartialEq)]
pub enum MergePullRequestByThreeWayError {
CommitMessageLengthExceeded(String),
ConcurrentReferenceUpdate(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FileContentSizeLimitExceeded(String),
FolderContentSizeLimitExceeded(String),
InvalidCommitId(String),
InvalidConflictDetailLevel(String),
InvalidConflictResolution(String),
InvalidConflictResolutionStrategy(String),
InvalidEmail(String),
InvalidFileMode(String),
InvalidPath(String),
InvalidPullRequestId(String),
InvalidReplacementContent(String),
InvalidReplacementType(String),
InvalidRepositoryName(String),
ManualMergeRequired(String),
MaximumConflictResolutionEntriesExceeded(String),
MaximumFileContentToLoadExceeded(String),
MaximumItemsToCompareExceeded(String),
MultipleConflictResolutionEntries(String),
NameLengthExceeded(String),
PathRequired(String),
PullRequestAlreadyClosed(String),
PullRequestApprovalRulesNotSatisfied(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
ReplacementContentRequired(String),
ReplacementTypeRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
RepositoryNotAssociatedWithPullRequest(String),
TipOfSourceReferenceIsDifferent(String),
TipsDivergenceExceeded(String),
}
impl MergePullRequestByThreeWayError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<MergePullRequestByThreeWayError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommitMessageLengthExceededException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::CommitMessageLengthExceeded(err.msg),
)
}
"ConcurrentReferenceUpdateException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::ConcurrentReferenceUpdate(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::EncryptionKeyUnavailable(err.msg),
)
}
"FileContentSizeLimitExceededException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::FileContentSizeLimitExceeded(err.msg),
)
}
"FolderContentSizeLimitExceededException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::FolderContentSizeLimitExceeded(err.msg),
)
}
"InvalidCommitIdException" => {
return RusotoError::Service(MergePullRequestByThreeWayError::InvalidCommitId(
err.msg,
))
}
"InvalidConflictDetailLevelException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::InvalidConflictDetailLevel(err.msg),
)
}
"InvalidConflictResolutionException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::InvalidConflictResolution(err.msg),
)
}
"InvalidConflictResolutionStrategyException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::InvalidConflictResolutionStrategy(err.msg),
)
}
"InvalidEmailException" => {
return RusotoError::Service(MergePullRequestByThreeWayError::InvalidEmail(
err.msg,
))
}
"InvalidFileModeException" => {
return RusotoError::Service(MergePullRequestByThreeWayError::InvalidFileMode(
err.msg,
))
}
"InvalidPathException" => {
return RusotoError::Service(MergePullRequestByThreeWayError::InvalidPath(
err.msg,
))
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::InvalidPullRequestId(err.msg),
)
}
"InvalidReplacementContentException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::InvalidReplacementContent(err.msg),
)
}
"InvalidReplacementTypeException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::InvalidReplacementType(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::InvalidRepositoryName(err.msg),
)
}
"ManualMergeRequiredException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::ManualMergeRequired(err.msg),
)
}
"MaximumConflictResolutionEntriesExceededException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::MaximumConflictResolutionEntriesExceeded(
err.msg,
),
)
}
"MaximumFileContentToLoadExceededException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::MaximumFileContentToLoadExceeded(err.msg),
)
}
"MaximumItemsToCompareExceededException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::MaximumItemsToCompareExceeded(err.msg),
)
}
"MultipleConflictResolutionEntriesException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::MultipleConflictResolutionEntries(err.msg),
)
}
"NameLengthExceededException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::NameLengthExceeded(err.msg),
)
}
"PathRequiredException" => {
return RusotoError::Service(MergePullRequestByThreeWayError::PathRequired(
err.msg,
))
}
"PullRequestAlreadyClosedException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::PullRequestAlreadyClosed(err.msg),
)
}
"PullRequestApprovalRulesNotSatisfiedException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::PullRequestApprovalRulesNotSatisfied(
err.msg,
),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::PullRequestIdRequired(err.msg),
)
}
"ReplacementContentRequiredException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::ReplacementContentRequired(err.msg),
)
}
"ReplacementTypeRequiredException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::ReplacementTypeRequired(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::RepositoryNameRequired(err.msg),
)
}
"RepositoryNotAssociatedWithPullRequestException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::RepositoryNotAssociatedWithPullRequest(
err.msg,
),
)
}
"TipOfSourceReferenceIsDifferentException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::TipOfSourceReferenceIsDifferent(err.msg),
)
}
"TipsDivergenceExceededException" => {
return RusotoError::Service(
MergePullRequestByThreeWayError::TipsDivergenceExceeded(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for MergePullRequestByThreeWayError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
MergePullRequestByThreeWayError::CommitMessageLengthExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::ConcurrentReferenceUpdate(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::FileContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::FolderContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::InvalidCommitId(ref cause) => write!(f, "{}", cause),
MergePullRequestByThreeWayError::InvalidConflictDetailLevel(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::InvalidConflictResolution(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::InvalidConflictResolutionStrategy(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::InvalidEmail(ref cause) => write!(f, "{}", cause),
MergePullRequestByThreeWayError::InvalidFileMode(ref cause) => write!(f, "{}", cause),
MergePullRequestByThreeWayError::InvalidPath(ref cause) => write!(f, "{}", cause),
MergePullRequestByThreeWayError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::InvalidReplacementContent(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::InvalidReplacementType(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::ManualMergeRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::MaximumConflictResolutionEntriesExceeded(
ref cause,
) => write!(f, "{}", cause),
MergePullRequestByThreeWayError::MaximumFileContentToLoadExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::MaximumItemsToCompareExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::MultipleConflictResolutionEntries(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::NameLengthExceeded(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::PathRequired(ref cause) => write!(f, "{}", cause),
MergePullRequestByThreeWayError::PullRequestAlreadyClosed(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::PullRequestApprovalRulesNotSatisfied(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::ReplacementContentRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::ReplacementTypeRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::RepositoryNotAssociatedWithPullRequest(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::TipOfSourceReferenceIsDifferent(ref cause) => {
write!(f, "{}", cause)
}
MergePullRequestByThreeWayError::TipsDivergenceExceeded(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for MergePullRequestByThreeWayError {}
#[derive(Debug, PartialEq)]
pub enum OverridePullRequestApprovalRulesError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidOverrideStatus(String),
InvalidPullRequestId(String),
InvalidRevisionId(String),
OverrideAlreadySet(String),
OverrideStatusRequired(String),
PullRequestAlreadyClosed(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
RevisionIdRequired(String),
RevisionNotCurrent(String),
}
impl OverridePullRequestApprovalRulesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<OverridePullRequestApprovalRulesError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::EncryptionIntegrityChecksFailed(
err.msg,
),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidOverrideStatusException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::InvalidOverrideStatus(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::InvalidPullRequestId(err.msg),
)
}
"InvalidRevisionIdException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::InvalidRevisionId(err.msg),
)
}
"OverrideAlreadySetException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::OverrideAlreadySet(err.msg),
)
}
"OverrideStatusRequiredException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::OverrideStatusRequired(err.msg),
)
}
"PullRequestAlreadyClosedException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::PullRequestAlreadyClosed(err.msg),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::PullRequestIdRequired(err.msg),
)
}
"RevisionIdRequiredException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::RevisionIdRequired(err.msg),
)
}
"RevisionNotCurrentException" => {
return RusotoError::Service(
OverridePullRequestApprovalRulesError::RevisionNotCurrent(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for OverridePullRequestApprovalRulesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
OverridePullRequestApprovalRulesError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::InvalidOverrideStatus(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::InvalidRevisionId(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::OverrideAlreadySet(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::OverrideStatusRequired(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::PullRequestAlreadyClosed(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::RevisionIdRequired(ref cause) => {
write!(f, "{}", cause)
}
OverridePullRequestApprovalRulesError::RevisionNotCurrent(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for OverridePullRequestApprovalRulesError {}
#[derive(Debug, PartialEq)]
pub enum PostCommentForComparedCommitError {
BeforeCommitIdAndAfterCommitIdAreSame(String),
ClientRequestTokenRequired(String),
CommentContentRequired(String),
CommentContentSizeLimitExceeded(String),
CommitDoesNotExist(String),
CommitIdRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
IdempotencyParameterMismatch(String),
InvalidClientRequestToken(String),
InvalidCommitId(String),
InvalidFileLocation(String),
InvalidFilePosition(String),
InvalidPath(String),
InvalidRelativeFileVersionEnum(String),
InvalidRepositoryName(String),
PathDoesNotExist(String),
PathRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl PostCommentForComparedCommitError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<PostCommentForComparedCommitError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BeforeCommitIdAndAfterCommitIdAreSameException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::BeforeCommitIdAndAfterCommitIdAreSame(
err.msg,
),
)
}
"ClientRequestTokenRequiredException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::ClientRequestTokenRequired(err.msg),
)
}
"CommentContentRequiredException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::CommentContentRequired(err.msg),
)
}
"CommentContentSizeLimitExceededException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::CommentContentSizeLimitExceeded(err.msg),
)
}
"CommitDoesNotExistException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::CommitDoesNotExist(err.msg),
)
}
"CommitIdRequiredException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::CommitIdRequired(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::EncryptionKeyUnavailable(err.msg),
)
}
"IdempotencyParameterMismatchException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::IdempotencyParameterMismatch(err.msg),
)
}
"InvalidClientRequestTokenException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::InvalidClientRequestToken(err.msg),
)
}
"InvalidCommitIdException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::InvalidCommitId(err.msg),
)
}
"InvalidFileLocationException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::InvalidFileLocation(err.msg),
)
}
"InvalidFilePositionException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::InvalidFilePosition(err.msg),
)
}
"InvalidPathException" => {
return RusotoError::Service(PostCommentForComparedCommitError::InvalidPath(
err.msg,
))
}
"InvalidRelativeFileVersionEnumException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::InvalidRelativeFileVersionEnum(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::InvalidRepositoryName(err.msg),
)
}
"PathDoesNotExistException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::PathDoesNotExist(err.msg),
)
}
"PathRequiredException" => {
return RusotoError::Service(PostCommentForComparedCommitError::PathRequired(
err.msg,
))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
PostCommentForComparedCommitError::RepositoryNameRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PostCommentForComparedCommitError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PostCommentForComparedCommitError::BeforeCommitIdAndAfterCommitIdAreSame(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::ClientRequestTokenRequired(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::CommentContentRequired(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::CommentContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::CommitDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::CommitIdRequired(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::IdempotencyParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::InvalidClientRequestToken(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::InvalidCommitId(ref cause) => write!(f, "{}", cause),
PostCommentForComparedCommitError::InvalidFileLocation(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::InvalidFilePosition(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::InvalidPath(ref cause) => write!(f, "{}", cause),
PostCommentForComparedCommitError::InvalidRelativeFileVersionEnum(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::PathDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::PathRequired(ref cause) => write!(f, "{}", cause),
PostCommentForComparedCommitError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForComparedCommitError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PostCommentForComparedCommitError {}
#[derive(Debug, PartialEq)]
pub enum PostCommentForPullRequestError {
BeforeCommitIdAndAfterCommitIdAreSame(String),
ClientRequestTokenRequired(String),
CommentContentRequired(String),
CommentContentSizeLimitExceeded(String),
CommitDoesNotExist(String),
CommitIdRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
IdempotencyParameterMismatch(String),
InvalidClientRequestToken(String),
InvalidCommitId(String),
InvalidFileLocation(String),
InvalidFilePosition(String),
InvalidPath(String),
InvalidPullRequestId(String),
InvalidRelativeFileVersionEnum(String),
InvalidRepositoryName(String),
PathDoesNotExist(String),
PathRequired(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
RepositoryNotAssociatedWithPullRequest(String),
}
impl PostCommentForPullRequestError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PostCommentForPullRequestError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BeforeCommitIdAndAfterCommitIdAreSameException" => {
return RusotoError::Service(
PostCommentForPullRequestError::BeforeCommitIdAndAfterCommitIdAreSame(
err.msg,
),
)
}
"ClientRequestTokenRequiredException" => {
return RusotoError::Service(
PostCommentForPullRequestError::ClientRequestTokenRequired(err.msg),
)
}
"CommentContentRequiredException" => {
return RusotoError::Service(
PostCommentForPullRequestError::CommentContentRequired(err.msg),
)
}
"CommentContentSizeLimitExceededException" => {
return RusotoError::Service(
PostCommentForPullRequestError::CommentContentSizeLimitExceeded(err.msg),
)
}
"CommitDoesNotExistException" => {
return RusotoError::Service(
PostCommentForPullRequestError::CommitDoesNotExist(err.msg),
)
}
"CommitIdRequiredException" => {
return RusotoError::Service(PostCommentForPullRequestError::CommitIdRequired(
err.msg,
))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
PostCommentForPullRequestError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
PostCommentForPullRequestError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
PostCommentForPullRequestError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
PostCommentForPullRequestError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
PostCommentForPullRequestError::EncryptionKeyUnavailable(err.msg),
)
}
"IdempotencyParameterMismatchException" => {
return RusotoError::Service(
PostCommentForPullRequestError::IdempotencyParameterMismatch(err.msg),
)
}
"InvalidClientRequestTokenException" => {
return RusotoError::Service(
PostCommentForPullRequestError::InvalidClientRequestToken(err.msg),
)
}
"InvalidCommitIdException" => {
return RusotoError::Service(PostCommentForPullRequestError::InvalidCommitId(
err.msg,
))
}
"InvalidFileLocationException" => {
return RusotoError::Service(
PostCommentForPullRequestError::InvalidFileLocation(err.msg),
)
}
"InvalidFilePositionException" => {
return RusotoError::Service(
PostCommentForPullRequestError::InvalidFilePosition(err.msg),
)
}
"InvalidPathException" => {
return RusotoError::Service(PostCommentForPullRequestError::InvalidPath(
err.msg,
))
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
PostCommentForPullRequestError::InvalidPullRequestId(err.msg),
)
}
"InvalidRelativeFileVersionEnumException" => {
return RusotoError::Service(
PostCommentForPullRequestError::InvalidRelativeFileVersionEnum(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
PostCommentForPullRequestError::InvalidRepositoryName(err.msg),
)
}
"PathDoesNotExistException" => {
return RusotoError::Service(PostCommentForPullRequestError::PathDoesNotExist(
err.msg,
))
}
"PathRequiredException" => {
return RusotoError::Service(PostCommentForPullRequestError::PathRequired(
err.msg,
))
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
PostCommentForPullRequestError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
PostCommentForPullRequestError::PullRequestIdRequired(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
PostCommentForPullRequestError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
PostCommentForPullRequestError::RepositoryNameRequired(err.msg),
)
}
"RepositoryNotAssociatedWithPullRequestException" => {
return RusotoError::Service(
PostCommentForPullRequestError::RepositoryNotAssociatedWithPullRequest(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PostCommentForPullRequestError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PostCommentForPullRequestError::BeforeCommitIdAndAfterCommitIdAreSame(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::ClientRequestTokenRequired(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::CommentContentRequired(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::CommentContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::CommitDoesNotExist(ref cause) => write!(f, "{}", cause),
PostCommentForPullRequestError::CommitIdRequired(ref cause) => write!(f, "{}", cause),
PostCommentForPullRequestError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::IdempotencyParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::InvalidClientRequestToken(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::InvalidCommitId(ref cause) => write!(f, "{}", cause),
PostCommentForPullRequestError::InvalidFileLocation(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::InvalidFilePosition(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::InvalidPath(ref cause) => write!(f, "{}", cause),
PostCommentForPullRequestError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::InvalidRelativeFileVersionEnum(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::PathDoesNotExist(ref cause) => write!(f, "{}", cause),
PostCommentForPullRequestError::PathRequired(ref cause) => write!(f, "{}", cause),
PostCommentForPullRequestError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
PostCommentForPullRequestError::RepositoryNotAssociatedWithPullRequest(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PostCommentForPullRequestError {}
#[derive(Debug, PartialEq)]
pub enum PostCommentReplyError {
ClientRequestTokenRequired(String),
CommentContentRequired(String),
CommentContentSizeLimitExceeded(String),
CommentDoesNotExist(String),
CommentIdRequired(String),
IdempotencyParameterMismatch(String),
InvalidClientRequestToken(String),
InvalidCommentId(String),
}
impl PostCommentReplyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PostCommentReplyError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ClientRequestTokenRequiredException" => {
return RusotoError::Service(PostCommentReplyError::ClientRequestTokenRequired(
err.msg,
))
}
"CommentContentRequiredException" => {
return RusotoError::Service(PostCommentReplyError::CommentContentRequired(
err.msg,
))
}
"CommentContentSizeLimitExceededException" => {
return RusotoError::Service(
PostCommentReplyError::CommentContentSizeLimitExceeded(err.msg),
)
}
"CommentDoesNotExistException" => {
return RusotoError::Service(PostCommentReplyError::CommentDoesNotExist(
err.msg,
))
}
"CommentIdRequiredException" => {
return RusotoError::Service(PostCommentReplyError::CommentIdRequired(err.msg))
}
"IdempotencyParameterMismatchException" => {
return RusotoError::Service(
PostCommentReplyError::IdempotencyParameterMismatch(err.msg),
)
}
"InvalidClientRequestTokenException" => {
return RusotoError::Service(PostCommentReplyError::InvalidClientRequestToken(
err.msg,
))
}
"InvalidCommentIdException" => {
return RusotoError::Service(PostCommentReplyError::InvalidCommentId(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PostCommentReplyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PostCommentReplyError::ClientRequestTokenRequired(ref cause) => write!(f, "{}", cause),
PostCommentReplyError::CommentContentRequired(ref cause) => write!(f, "{}", cause),
PostCommentReplyError::CommentContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
PostCommentReplyError::CommentDoesNotExist(ref cause) => write!(f, "{}", cause),
PostCommentReplyError::CommentIdRequired(ref cause) => write!(f, "{}", cause),
PostCommentReplyError::IdempotencyParameterMismatch(ref cause) => {
write!(f, "{}", cause)
}
PostCommentReplyError::InvalidClientRequestToken(ref cause) => write!(f, "{}", cause),
PostCommentReplyError::InvalidCommentId(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PostCommentReplyError {}
#[derive(Debug, PartialEq)]
pub enum PutCommentReactionError {
CommentDeleted(String),
CommentDoesNotExist(String),
CommentIdRequired(String),
InvalidCommentId(String),
InvalidReactionValue(String),
ReactionLimitExceeded(String),
ReactionValueRequired(String),
}
impl PutCommentReactionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutCommentReactionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommentDeletedException" => {
return RusotoError::Service(PutCommentReactionError::CommentDeleted(err.msg))
}
"CommentDoesNotExistException" => {
return RusotoError::Service(PutCommentReactionError::CommentDoesNotExist(
err.msg,
))
}
"CommentIdRequiredException" => {
return RusotoError::Service(PutCommentReactionError::CommentIdRequired(
err.msg,
))
}
"InvalidCommentIdException" => {
return RusotoError::Service(PutCommentReactionError::InvalidCommentId(err.msg))
}
"InvalidReactionValueException" => {
return RusotoError::Service(PutCommentReactionError::InvalidReactionValue(
err.msg,
))
}
"ReactionLimitExceededException" => {
return RusotoError::Service(PutCommentReactionError::ReactionLimitExceeded(
err.msg,
))
}
"ReactionValueRequiredException" => {
return RusotoError::Service(PutCommentReactionError::ReactionValueRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutCommentReactionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutCommentReactionError::CommentDeleted(ref cause) => write!(f, "{}", cause),
PutCommentReactionError::CommentDoesNotExist(ref cause) => write!(f, "{}", cause),
PutCommentReactionError::CommentIdRequired(ref cause) => write!(f, "{}", cause),
PutCommentReactionError::InvalidCommentId(ref cause) => write!(f, "{}", cause),
PutCommentReactionError::InvalidReactionValue(ref cause) => write!(f, "{}", cause),
PutCommentReactionError::ReactionLimitExceeded(ref cause) => write!(f, "{}", cause),
PutCommentReactionError::ReactionValueRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutCommentReactionError {}
#[derive(Debug, PartialEq)]
pub enum PutFileError {
BranchDoesNotExist(String),
BranchNameIsTagName(String),
BranchNameRequired(String),
CommitMessageLengthExceeded(String),
DirectoryNameConflictsWithFileName(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
FileContentRequired(String),
FileContentSizeLimitExceeded(String),
FileNameConflictsWithDirectoryName(String),
FilePathConflictsWithSubmodulePath(String),
FolderContentSizeLimitExceeded(String),
InvalidBranchName(String),
InvalidDeletionParameter(String),
InvalidEmail(String),
InvalidFileMode(String),
InvalidParentCommitId(String),
InvalidPath(String),
InvalidRepositoryName(String),
NameLengthExceeded(String),
ParentCommitDoesNotExist(String),
ParentCommitIdOutdated(String),
ParentCommitIdRequired(String),
PathRequired(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
SameFileContent(String),
}
impl PutFileError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutFileError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BranchDoesNotExistException" => {
return RusotoError::Service(PutFileError::BranchDoesNotExist(err.msg))
}
"BranchNameIsTagNameException" => {
return RusotoError::Service(PutFileError::BranchNameIsTagName(err.msg))
}
"BranchNameRequiredException" => {
return RusotoError::Service(PutFileError::BranchNameRequired(err.msg))
}
"CommitMessageLengthExceededException" => {
return RusotoError::Service(PutFileError::CommitMessageLengthExceeded(err.msg))
}
"DirectoryNameConflictsWithFileNameException" => {
return RusotoError::Service(PutFileError::DirectoryNameConflictsWithFileName(
err.msg,
))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(PutFileError::EncryptionIntegrityChecksFailed(
err.msg,
))
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(PutFileError::EncryptionKeyAccessDenied(err.msg))
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(PutFileError::EncryptionKeyDisabled(err.msg))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(PutFileError::EncryptionKeyNotFound(err.msg))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(PutFileError::EncryptionKeyUnavailable(err.msg))
}
"FileContentRequiredException" => {
return RusotoError::Service(PutFileError::FileContentRequired(err.msg))
}
"FileContentSizeLimitExceededException" => {
return RusotoError::Service(PutFileError::FileContentSizeLimitExceeded(
err.msg,
))
}
"FileNameConflictsWithDirectoryNameException" => {
return RusotoError::Service(PutFileError::FileNameConflictsWithDirectoryName(
err.msg,
))
}
"FilePathConflictsWithSubmodulePathException" => {
return RusotoError::Service(PutFileError::FilePathConflictsWithSubmodulePath(
err.msg,
))
}
"FolderContentSizeLimitExceededException" => {
return RusotoError::Service(PutFileError::FolderContentSizeLimitExceeded(
err.msg,
))
}
"InvalidBranchNameException" => {
return RusotoError::Service(PutFileError::InvalidBranchName(err.msg))
}
"InvalidDeletionParameterException" => {
return RusotoError::Service(PutFileError::InvalidDeletionParameter(err.msg))
}
"InvalidEmailException" => {
return RusotoError::Service(PutFileError::InvalidEmail(err.msg))
}
"InvalidFileModeException" => {
return RusotoError::Service(PutFileError::InvalidFileMode(err.msg))
}
"InvalidParentCommitIdException" => {
return RusotoError::Service(PutFileError::InvalidParentCommitId(err.msg))
}
"InvalidPathException" => {
return RusotoError::Service(PutFileError::InvalidPath(err.msg))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(PutFileError::InvalidRepositoryName(err.msg))
}
"NameLengthExceededException" => {
return RusotoError::Service(PutFileError::NameLengthExceeded(err.msg))
}
"ParentCommitDoesNotExistException" => {
return RusotoError::Service(PutFileError::ParentCommitDoesNotExist(err.msg))
}
"ParentCommitIdOutdatedException" => {
return RusotoError::Service(PutFileError::ParentCommitIdOutdated(err.msg))
}
"ParentCommitIdRequiredException" => {
return RusotoError::Service(PutFileError::ParentCommitIdRequired(err.msg))
}
"PathRequiredException" => {
return RusotoError::Service(PutFileError::PathRequired(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(PutFileError::RepositoryDoesNotExist(err.msg))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(PutFileError::RepositoryNameRequired(err.msg))
}
"SameFileContentException" => {
return RusotoError::Service(PutFileError::SameFileContent(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutFileError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutFileError::BranchDoesNotExist(ref cause) => write!(f, "{}", cause),
PutFileError::BranchNameIsTagName(ref cause) => write!(f, "{}", cause),
PutFileError::BranchNameRequired(ref cause) => write!(f, "{}", cause),
PutFileError::CommitMessageLengthExceeded(ref cause) => write!(f, "{}", cause),
PutFileError::DirectoryNameConflictsWithFileName(ref cause) => write!(f, "{}", cause),
PutFileError::EncryptionIntegrityChecksFailed(ref cause) => write!(f, "{}", cause),
PutFileError::EncryptionKeyAccessDenied(ref cause) => write!(f, "{}", cause),
PutFileError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
PutFileError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
PutFileError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
PutFileError::FileContentRequired(ref cause) => write!(f, "{}", cause),
PutFileError::FileContentSizeLimitExceeded(ref cause) => write!(f, "{}", cause),
PutFileError::FileNameConflictsWithDirectoryName(ref cause) => write!(f, "{}", cause),
PutFileError::FilePathConflictsWithSubmodulePath(ref cause) => write!(f, "{}", cause),
PutFileError::FolderContentSizeLimitExceeded(ref cause) => write!(f, "{}", cause),
PutFileError::InvalidBranchName(ref cause) => write!(f, "{}", cause),
PutFileError::InvalidDeletionParameter(ref cause) => write!(f, "{}", cause),
PutFileError::InvalidEmail(ref cause) => write!(f, "{}", cause),
PutFileError::InvalidFileMode(ref cause) => write!(f, "{}", cause),
PutFileError::InvalidParentCommitId(ref cause) => write!(f, "{}", cause),
PutFileError::InvalidPath(ref cause) => write!(f, "{}", cause),
PutFileError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
PutFileError::NameLengthExceeded(ref cause) => write!(f, "{}", cause),
PutFileError::ParentCommitDoesNotExist(ref cause) => write!(f, "{}", cause),
PutFileError::ParentCommitIdOutdated(ref cause) => write!(f, "{}", cause),
PutFileError::ParentCommitIdRequired(ref cause) => write!(f, "{}", cause),
PutFileError::PathRequired(ref cause) => write!(f, "{}", cause),
PutFileError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
PutFileError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
PutFileError::SameFileContent(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutFileError {}
#[derive(Debug, PartialEq)]
pub enum PutRepositoryTriggersError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidRepositoryName(String),
InvalidRepositoryTriggerBranchName(String),
InvalidRepositoryTriggerCustomData(String),
InvalidRepositoryTriggerDestinationArn(String),
InvalidRepositoryTriggerEvents(String),
InvalidRepositoryTriggerName(String),
InvalidRepositoryTriggerRegion(String),
MaximumBranchesExceeded(String),
MaximumRepositoryTriggersExceeded(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
RepositoryTriggerBranchNameListRequired(String),
RepositoryTriggerDestinationArnRequired(String),
RepositoryTriggerEventsListRequired(String),
RepositoryTriggerNameRequired(String),
RepositoryTriggersListRequired(String),
}
impl PutRepositoryTriggersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutRepositoryTriggersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
PutRepositoryTriggersError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
PutRepositoryTriggersError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(PutRepositoryTriggersError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(PutRepositoryTriggersError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
PutRepositoryTriggersError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(PutRepositoryTriggersError::InvalidRepositoryName(
err.msg,
))
}
"InvalidRepositoryTriggerBranchNameException" => {
return RusotoError::Service(
PutRepositoryTriggersError::InvalidRepositoryTriggerBranchName(err.msg),
)
}
"InvalidRepositoryTriggerCustomDataException" => {
return RusotoError::Service(
PutRepositoryTriggersError::InvalidRepositoryTriggerCustomData(err.msg),
)
}
"InvalidRepositoryTriggerDestinationArnException" => {
return RusotoError::Service(
PutRepositoryTriggersError::InvalidRepositoryTriggerDestinationArn(err.msg),
)
}
"InvalidRepositoryTriggerEventsException" => {
return RusotoError::Service(
PutRepositoryTriggersError::InvalidRepositoryTriggerEvents(err.msg),
)
}
"InvalidRepositoryTriggerNameException" => {
return RusotoError::Service(
PutRepositoryTriggersError::InvalidRepositoryTriggerName(err.msg),
)
}
"InvalidRepositoryTriggerRegionException" => {
return RusotoError::Service(
PutRepositoryTriggersError::InvalidRepositoryTriggerRegion(err.msg),
)
}
"MaximumBranchesExceededException" => {
return RusotoError::Service(
PutRepositoryTriggersError::MaximumBranchesExceeded(err.msg),
)
}
"MaximumRepositoryTriggersExceededException" => {
return RusotoError::Service(
PutRepositoryTriggersError::MaximumRepositoryTriggersExceeded(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
PutRepositoryTriggersError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
PutRepositoryTriggersError::RepositoryNameRequired(err.msg),
)
}
"RepositoryTriggerBranchNameListRequiredException" => {
return RusotoError::Service(
PutRepositoryTriggersError::RepositoryTriggerBranchNameListRequired(
err.msg,
),
)
}
"RepositoryTriggerDestinationArnRequiredException" => {
return RusotoError::Service(
PutRepositoryTriggersError::RepositoryTriggerDestinationArnRequired(
err.msg,
),
)
}
"RepositoryTriggerEventsListRequiredException" => {
return RusotoError::Service(
PutRepositoryTriggersError::RepositoryTriggerEventsListRequired(err.msg),
)
}
"RepositoryTriggerNameRequiredException" => {
return RusotoError::Service(
PutRepositoryTriggersError::RepositoryTriggerNameRequired(err.msg),
)
}
"RepositoryTriggersListRequiredException" => {
return RusotoError::Service(
PutRepositoryTriggersError::RepositoryTriggersListRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutRepositoryTriggersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutRepositoryTriggersError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
PutRepositoryTriggersError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
PutRepositoryTriggersError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
PutRepositoryTriggersError::InvalidRepositoryTriggerBranchName(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::InvalidRepositoryTriggerCustomData(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::InvalidRepositoryTriggerDestinationArn(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::InvalidRepositoryTriggerEvents(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::InvalidRepositoryTriggerName(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::InvalidRepositoryTriggerRegion(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::MaximumBranchesExceeded(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::MaximumRepositoryTriggersExceeded(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
PutRepositoryTriggersError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
PutRepositoryTriggersError::RepositoryTriggerBranchNameListRequired(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::RepositoryTriggerDestinationArnRequired(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::RepositoryTriggerEventsListRequired(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::RepositoryTriggerNameRequired(ref cause) => {
write!(f, "{}", cause)
}
PutRepositoryTriggersError::RepositoryTriggersListRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for PutRepositoryTriggersError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
InvalidRepositoryName(String),
InvalidResourceArn(String),
InvalidSystemTagUsage(String),
InvalidTagsMap(String),
RepositoryDoesNotExist(String),
ResourceArnRequired(String),
TagPolicy(String),
TagsMapRequired(String),
TooManyTags(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidRepositoryNameException" => {
return RusotoError::Service(TagResourceError::InvalidRepositoryName(err.msg))
}
"InvalidResourceArnException" => {
return RusotoError::Service(TagResourceError::InvalidResourceArn(err.msg))
}
"InvalidSystemTagUsageException" => {
return RusotoError::Service(TagResourceError::InvalidSystemTagUsage(err.msg))
}
"InvalidTagsMapException" => {
return RusotoError::Service(TagResourceError::InvalidTagsMap(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(TagResourceError::RepositoryDoesNotExist(err.msg))
}
"ResourceArnRequiredException" => {
return RusotoError::Service(TagResourceError::ResourceArnRequired(err.msg))
}
"TagPolicyException" => {
return RusotoError::Service(TagResourceError::TagPolicy(err.msg))
}
"TagsMapRequiredException" => {
return RusotoError::Service(TagResourceError::TagsMapRequired(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(TagResourceError::TooManyTags(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::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidResourceArn(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidSystemTagUsage(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidTagsMap(ref cause) => write!(f, "{}", cause),
TagResourceError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceArnRequired(ref cause) => write!(f, "{}", cause),
TagResourceError::TagPolicy(ref cause) => write!(f, "{}", cause),
TagResourceError::TagsMapRequired(ref cause) => write!(f, "{}", cause),
TagResourceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum TestRepositoryTriggersError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidRepositoryName(String),
InvalidRepositoryTriggerBranchName(String),
InvalidRepositoryTriggerCustomData(String),
InvalidRepositoryTriggerDestinationArn(String),
InvalidRepositoryTriggerEvents(String),
InvalidRepositoryTriggerName(String),
InvalidRepositoryTriggerRegion(String),
MaximumBranchesExceeded(String),
MaximumRepositoryTriggersExceeded(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
RepositoryTriggerBranchNameListRequired(String),
RepositoryTriggerDestinationArnRequired(String),
RepositoryTriggerEventsListRequired(String),
RepositoryTriggerNameRequired(String),
RepositoryTriggersListRequired(String),
}
impl TestRepositoryTriggersError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TestRepositoryTriggersError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
TestRepositoryTriggersError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
TestRepositoryTriggersError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
TestRepositoryTriggersError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
TestRepositoryTriggersError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
TestRepositoryTriggersError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
TestRepositoryTriggersError::InvalidRepositoryName(err.msg),
)
}
"InvalidRepositoryTriggerBranchNameException" => {
return RusotoError::Service(
TestRepositoryTriggersError::InvalidRepositoryTriggerBranchName(err.msg),
)
}
"InvalidRepositoryTriggerCustomDataException" => {
return RusotoError::Service(
TestRepositoryTriggersError::InvalidRepositoryTriggerCustomData(err.msg),
)
}
"InvalidRepositoryTriggerDestinationArnException" => {
return RusotoError::Service(
TestRepositoryTriggersError::InvalidRepositoryTriggerDestinationArn(
err.msg,
),
)
}
"InvalidRepositoryTriggerEventsException" => {
return RusotoError::Service(
TestRepositoryTriggersError::InvalidRepositoryTriggerEvents(err.msg),
)
}
"InvalidRepositoryTriggerNameException" => {
return RusotoError::Service(
TestRepositoryTriggersError::InvalidRepositoryTriggerName(err.msg),
)
}
"InvalidRepositoryTriggerRegionException" => {
return RusotoError::Service(
TestRepositoryTriggersError::InvalidRepositoryTriggerRegion(err.msg),
)
}
"MaximumBranchesExceededException" => {
return RusotoError::Service(
TestRepositoryTriggersError::MaximumBranchesExceeded(err.msg),
)
}
"MaximumRepositoryTriggersExceededException" => {
return RusotoError::Service(
TestRepositoryTriggersError::MaximumRepositoryTriggersExceeded(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
TestRepositoryTriggersError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
TestRepositoryTriggersError::RepositoryNameRequired(err.msg),
)
}
"RepositoryTriggerBranchNameListRequiredException" => {
return RusotoError::Service(
TestRepositoryTriggersError::RepositoryTriggerBranchNameListRequired(
err.msg,
),
)
}
"RepositoryTriggerDestinationArnRequiredException" => {
return RusotoError::Service(
TestRepositoryTriggersError::RepositoryTriggerDestinationArnRequired(
err.msg,
),
)
}
"RepositoryTriggerEventsListRequiredException" => {
return RusotoError::Service(
TestRepositoryTriggersError::RepositoryTriggerEventsListRequired(err.msg),
)
}
"RepositoryTriggerNameRequiredException" => {
return RusotoError::Service(
TestRepositoryTriggersError::RepositoryTriggerNameRequired(err.msg),
)
}
"RepositoryTriggersListRequiredException" => {
return RusotoError::Service(
TestRepositoryTriggersError::RepositoryTriggersListRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TestRepositoryTriggersError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TestRepositoryTriggersError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
TestRepositoryTriggersError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
TestRepositoryTriggersError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
TestRepositoryTriggersError::InvalidRepositoryTriggerBranchName(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::InvalidRepositoryTriggerCustomData(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::InvalidRepositoryTriggerDestinationArn(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::InvalidRepositoryTriggerEvents(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::InvalidRepositoryTriggerName(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::InvalidRepositoryTriggerRegion(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::MaximumBranchesExceeded(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::MaximumRepositoryTriggersExceeded(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::RepositoryTriggerBranchNameListRequired(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::RepositoryTriggerDestinationArnRequired(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::RepositoryTriggerEventsListRequired(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::RepositoryTriggerNameRequired(ref cause) => {
write!(f, "{}", cause)
}
TestRepositoryTriggersError::RepositoryTriggersListRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for TestRepositoryTriggersError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
InvalidRepositoryName(String),
InvalidResourceArn(String),
InvalidSystemTagUsage(String),
InvalidTagKeysList(String),
RepositoryDoesNotExist(String),
ResourceArnRequired(String),
TagKeysListRequired(String),
TagPolicy(String),
TooManyTags(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidRepositoryNameException" => {
return RusotoError::Service(UntagResourceError::InvalidRepositoryName(err.msg))
}
"InvalidResourceArnException" => {
return RusotoError::Service(UntagResourceError::InvalidResourceArn(err.msg))
}
"InvalidSystemTagUsageException" => {
return RusotoError::Service(UntagResourceError::InvalidSystemTagUsage(err.msg))
}
"InvalidTagKeysListException" => {
return RusotoError::Service(UntagResourceError::InvalidTagKeysList(err.msg))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(UntagResourceError::RepositoryDoesNotExist(
err.msg,
))
}
"ResourceArnRequiredException" => {
return RusotoError::Service(UntagResourceError::ResourceArnRequired(err.msg))
}
"TagKeysListRequiredException" => {
return RusotoError::Service(UntagResourceError::TagKeysListRequired(err.msg))
}
"TagPolicyException" => {
return RusotoError::Service(UntagResourceError::TagPolicy(err.msg))
}
"TooManyTagsException" => {
return RusotoError::Service(UntagResourceError::TooManyTags(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::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidResourceArn(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidSystemTagUsage(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidTagKeysList(ref cause) => write!(f, "{}", cause),
UntagResourceError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceArnRequired(ref cause) => write!(f, "{}", cause),
UntagResourceError::TagKeysListRequired(ref cause) => write!(f, "{}", cause),
UntagResourceError::TagPolicy(ref cause) => write!(f, "{}", cause),
UntagResourceError::TooManyTags(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApprovalRuleTemplateContentError {
ApprovalRuleTemplateContentRequired(String),
ApprovalRuleTemplateDoesNotExist(String),
ApprovalRuleTemplateNameRequired(String),
InvalidApprovalRuleTemplateContent(String),
InvalidApprovalRuleTemplateName(String),
InvalidRuleContentSha256(String),
}
impl UpdateApprovalRuleTemplateContentError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateApprovalRuleTemplateContentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleTemplateContentRequiredException" => {
return RusotoError::Service(
UpdateApprovalRuleTemplateContentError::ApprovalRuleTemplateContentRequired(
err.msg,
),
)
}
"ApprovalRuleTemplateDoesNotExistException" => {
return RusotoError::Service(
UpdateApprovalRuleTemplateContentError::ApprovalRuleTemplateDoesNotExist(
err.msg,
),
)
}
"ApprovalRuleTemplateNameRequiredException" => {
return RusotoError::Service(
UpdateApprovalRuleTemplateContentError::ApprovalRuleTemplateNameRequired(
err.msg,
),
)
}
"InvalidApprovalRuleTemplateContentException" => {
return RusotoError::Service(
UpdateApprovalRuleTemplateContentError::InvalidApprovalRuleTemplateContent(
err.msg,
),
)
}
"InvalidApprovalRuleTemplateNameException" => {
return RusotoError::Service(
UpdateApprovalRuleTemplateContentError::InvalidApprovalRuleTemplateName(
err.msg,
),
)
}
"InvalidRuleContentSha256Exception" => {
return RusotoError::Service(
UpdateApprovalRuleTemplateContentError::InvalidRuleContentSha256(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateApprovalRuleTemplateContentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateApprovalRuleTemplateContentError::ApprovalRuleTemplateContentRequired(
ref cause,
) => write!(f, "{}", cause),
UpdateApprovalRuleTemplateContentError::ApprovalRuleTemplateDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdateApprovalRuleTemplateContentError::ApprovalRuleTemplateNameRequired(ref cause) => {
write!(f, "{}", cause)
}
UpdateApprovalRuleTemplateContentError::InvalidApprovalRuleTemplateContent(
ref cause,
) => write!(f, "{}", cause),
UpdateApprovalRuleTemplateContentError::InvalidApprovalRuleTemplateName(ref cause) => {
write!(f, "{}", cause)
}
UpdateApprovalRuleTemplateContentError::InvalidRuleContentSha256(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateApprovalRuleTemplateContentError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApprovalRuleTemplateDescriptionError {
ApprovalRuleTemplateDoesNotExist(String),
ApprovalRuleTemplateNameRequired(String),
InvalidApprovalRuleTemplateDescription(String),
InvalidApprovalRuleTemplateName(String),
}
impl UpdateApprovalRuleTemplateDescriptionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateApprovalRuleTemplateDescriptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleTemplateDoesNotExistException" => return RusotoError::Service(UpdateApprovalRuleTemplateDescriptionError::ApprovalRuleTemplateDoesNotExist(err.msg)),
"ApprovalRuleTemplateNameRequiredException" => return RusotoError::Service(UpdateApprovalRuleTemplateDescriptionError::ApprovalRuleTemplateNameRequired(err.msg)),
"InvalidApprovalRuleTemplateDescriptionException" => return RusotoError::Service(UpdateApprovalRuleTemplateDescriptionError::InvalidApprovalRuleTemplateDescription(err.msg)),
"InvalidApprovalRuleTemplateNameException" => return RusotoError::Service(UpdateApprovalRuleTemplateDescriptionError::InvalidApprovalRuleTemplateName(err.msg)),
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateApprovalRuleTemplateDescriptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateApprovalRuleTemplateDescriptionError::ApprovalRuleTemplateDoesNotExist(
ref cause,
) => write!(f, "{}", cause),
UpdateApprovalRuleTemplateDescriptionError::ApprovalRuleTemplateNameRequired(
ref cause,
) => write!(f, "{}", cause),
UpdateApprovalRuleTemplateDescriptionError::InvalidApprovalRuleTemplateDescription(
ref cause,
) => write!(f, "{}", cause),
UpdateApprovalRuleTemplateDescriptionError::InvalidApprovalRuleTemplateName(
ref cause,
) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateApprovalRuleTemplateDescriptionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateApprovalRuleTemplateNameError {
ApprovalRuleTemplateDoesNotExist(String),
ApprovalRuleTemplateNameAlreadyExists(String),
ApprovalRuleTemplateNameRequired(String),
InvalidApprovalRuleTemplateName(String),
}
impl UpdateApprovalRuleTemplateNameError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateApprovalRuleTemplateNameError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleTemplateDoesNotExistException" => {
return RusotoError::Service(
UpdateApprovalRuleTemplateNameError::ApprovalRuleTemplateDoesNotExist(
err.msg,
),
)
}
"ApprovalRuleTemplateNameAlreadyExistsException" => {
return RusotoError::Service(
UpdateApprovalRuleTemplateNameError::ApprovalRuleTemplateNameAlreadyExists(
err.msg,
),
)
}
"ApprovalRuleTemplateNameRequiredException" => {
return RusotoError::Service(
UpdateApprovalRuleTemplateNameError::ApprovalRuleTemplateNameRequired(
err.msg,
),
)
}
"InvalidApprovalRuleTemplateNameException" => {
return RusotoError::Service(
UpdateApprovalRuleTemplateNameError::InvalidApprovalRuleTemplateName(
err.msg,
),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateApprovalRuleTemplateNameError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateApprovalRuleTemplateNameError::ApprovalRuleTemplateDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdateApprovalRuleTemplateNameError::ApprovalRuleTemplateNameAlreadyExists(
ref cause,
) => write!(f, "{}", cause),
UpdateApprovalRuleTemplateNameError::ApprovalRuleTemplateNameRequired(ref cause) => {
write!(f, "{}", cause)
}
UpdateApprovalRuleTemplateNameError::InvalidApprovalRuleTemplateName(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateApprovalRuleTemplateNameError {}
#[derive(Debug, PartialEq)]
pub enum UpdateCommentError {
CommentContentRequired(String),
CommentContentSizeLimitExceeded(String),
CommentDeleted(String),
CommentDoesNotExist(String),
CommentIdRequired(String),
CommentNotCreatedByCaller(String),
InvalidCommentId(String),
}
impl UpdateCommentError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateCommentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"CommentContentRequiredException" => {
return RusotoError::Service(UpdateCommentError::CommentContentRequired(
err.msg,
))
}
"CommentContentSizeLimitExceededException" => {
return RusotoError::Service(
UpdateCommentError::CommentContentSizeLimitExceeded(err.msg),
)
}
"CommentDeletedException" => {
return RusotoError::Service(UpdateCommentError::CommentDeleted(err.msg))
}
"CommentDoesNotExistException" => {
return RusotoError::Service(UpdateCommentError::CommentDoesNotExist(err.msg))
}
"CommentIdRequiredException" => {
return RusotoError::Service(UpdateCommentError::CommentIdRequired(err.msg))
}
"CommentNotCreatedByCallerException" => {
return RusotoError::Service(UpdateCommentError::CommentNotCreatedByCaller(
err.msg,
))
}
"InvalidCommentIdException" => {
return RusotoError::Service(UpdateCommentError::InvalidCommentId(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateCommentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateCommentError::CommentContentRequired(ref cause) => write!(f, "{}", cause),
UpdateCommentError::CommentContentSizeLimitExceeded(ref cause) => {
write!(f, "{}", cause)
}
UpdateCommentError::CommentDeleted(ref cause) => write!(f, "{}", cause),
UpdateCommentError::CommentDoesNotExist(ref cause) => write!(f, "{}", cause),
UpdateCommentError::CommentIdRequired(ref cause) => write!(f, "{}", cause),
UpdateCommentError::CommentNotCreatedByCaller(ref cause) => write!(f, "{}", cause),
UpdateCommentError::InvalidCommentId(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateCommentError {}
#[derive(Debug, PartialEq)]
pub enum UpdateDefaultBranchError {
BranchDoesNotExist(String),
BranchNameRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidBranchName(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl UpdateDefaultBranchError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateDefaultBranchError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"BranchDoesNotExistException" => {
return RusotoError::Service(UpdateDefaultBranchError::BranchDoesNotExist(
err.msg,
))
}
"BranchNameRequiredException" => {
return RusotoError::Service(UpdateDefaultBranchError::BranchNameRequired(
err.msg,
))
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
UpdateDefaultBranchError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
UpdateDefaultBranchError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(UpdateDefaultBranchError::EncryptionKeyDisabled(
err.msg,
))
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(UpdateDefaultBranchError::EncryptionKeyNotFound(
err.msg,
))
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
UpdateDefaultBranchError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidBranchNameException" => {
return RusotoError::Service(UpdateDefaultBranchError::InvalidBranchName(
err.msg,
))
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(UpdateDefaultBranchError::InvalidRepositoryName(
err.msg,
))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(UpdateDefaultBranchError::RepositoryDoesNotExist(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(UpdateDefaultBranchError::RepositoryNameRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateDefaultBranchError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateDefaultBranchError::BranchDoesNotExist(ref cause) => write!(f, "{}", cause),
UpdateDefaultBranchError::BranchNameRequired(ref cause) => write!(f, "{}", cause),
UpdateDefaultBranchError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
UpdateDefaultBranchError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
UpdateDefaultBranchError::EncryptionKeyDisabled(ref cause) => write!(f, "{}", cause),
UpdateDefaultBranchError::EncryptionKeyNotFound(ref cause) => write!(f, "{}", cause),
UpdateDefaultBranchError::EncryptionKeyUnavailable(ref cause) => write!(f, "{}", cause),
UpdateDefaultBranchError::InvalidBranchName(ref cause) => write!(f, "{}", cause),
UpdateDefaultBranchError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
UpdateDefaultBranchError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
UpdateDefaultBranchError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateDefaultBranchError {}
#[derive(Debug, PartialEq)]
pub enum UpdatePullRequestApprovalRuleContentError {
ApprovalRuleContentRequired(String),
ApprovalRuleDoesNotExist(String),
ApprovalRuleNameRequired(String),
CannotModifyApprovalRuleFromTemplate(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidApprovalRuleContent(String),
InvalidApprovalRuleName(String),
InvalidPullRequestId(String),
InvalidRuleContentSha256(String),
PullRequestAlreadyClosed(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
}
impl UpdatePullRequestApprovalRuleContentError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdatePullRequestApprovalRuleContentError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalRuleContentRequiredException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::ApprovalRuleContentRequired(
err.msg,
),
)
}
"ApprovalRuleDoesNotExistException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::ApprovalRuleDoesNotExist(
err.msg,
),
)
}
"ApprovalRuleNameRequiredException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::ApprovalRuleNameRequired(
err.msg,
),
)
}
"CannotModifyApprovalRuleFromTemplateException" => return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::CannotModifyApprovalRuleFromTemplate(
err.msg,
),
),
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::EncryptionIntegrityChecksFailed(
err.msg,
),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::EncryptionKeyAccessDenied(
err.msg,
),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::EncryptionKeyUnavailable(
err.msg,
),
)
}
"InvalidApprovalRuleContentException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::InvalidApprovalRuleContent(
err.msg,
),
)
}
"InvalidApprovalRuleNameException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::InvalidApprovalRuleName(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::InvalidPullRequestId(err.msg),
)
}
"InvalidRuleContentSha256Exception" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::InvalidRuleContentSha256(
err.msg,
),
)
}
"PullRequestAlreadyClosedException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::PullRequestAlreadyClosed(
err.msg,
),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
UpdatePullRequestApprovalRuleContentError::PullRequestIdRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdatePullRequestApprovalRuleContentError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdatePullRequestApprovalRuleContentError::ApprovalRuleContentRequired(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::ApprovalRuleDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::ApprovalRuleNameRequired(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::CannotModifyApprovalRuleFromTemplate(
ref cause,
) => write!(f, "{}", cause),
UpdatePullRequestApprovalRuleContentError::EncryptionIntegrityChecksFailed(
ref cause,
) => write!(f, "{}", cause),
UpdatePullRequestApprovalRuleContentError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::InvalidApprovalRuleContent(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::InvalidApprovalRuleName(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::InvalidRuleContentSha256(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::PullRequestAlreadyClosed(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalRuleContentError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdatePullRequestApprovalRuleContentError {}
#[derive(Debug, PartialEq)]
pub enum UpdatePullRequestApprovalStateError {
ApprovalStateRequired(String),
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidApprovalState(String),
InvalidPullRequestId(String),
InvalidRevisionId(String),
MaximumNumberOfApprovalsExceeded(String),
PullRequestAlreadyClosed(String),
PullRequestCannotBeApprovedByAuthor(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
RevisionIdRequired(String),
RevisionNotCurrent(String),
}
impl UpdatePullRequestApprovalStateError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdatePullRequestApprovalStateError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"ApprovalStateRequiredException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::ApprovalStateRequired(err.msg),
)
}
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::EncryptionIntegrityChecksFailed(
err.msg,
),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidApprovalStateException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::InvalidApprovalState(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::InvalidPullRequestId(err.msg),
)
}
"InvalidRevisionIdException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::InvalidRevisionId(err.msg),
)
}
"MaximumNumberOfApprovalsExceededException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::MaximumNumberOfApprovalsExceeded(
err.msg,
),
)
}
"PullRequestAlreadyClosedException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::PullRequestAlreadyClosed(err.msg),
)
}
"PullRequestCannotBeApprovedByAuthorException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::PullRequestCannotBeApprovedByAuthor(
err.msg,
),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::PullRequestIdRequired(err.msg),
)
}
"RevisionIdRequiredException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::RevisionIdRequired(err.msg),
)
}
"RevisionNotCurrentException" => {
return RusotoError::Service(
UpdatePullRequestApprovalStateError::RevisionNotCurrent(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdatePullRequestApprovalStateError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdatePullRequestApprovalStateError::ApprovalStateRequired(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::InvalidApprovalState(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::InvalidRevisionId(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::MaximumNumberOfApprovalsExceeded(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::PullRequestAlreadyClosed(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::PullRequestCannotBeApprovedByAuthor(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::RevisionIdRequired(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestApprovalStateError::RevisionNotCurrent(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdatePullRequestApprovalStateError {}
#[derive(Debug, PartialEq)]
pub enum UpdatePullRequestDescriptionError {
InvalidDescription(String),
InvalidPullRequestId(String),
PullRequestAlreadyClosed(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
}
impl UpdatePullRequestDescriptionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdatePullRequestDescriptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidDescriptionException" => {
return RusotoError::Service(
UpdatePullRequestDescriptionError::InvalidDescription(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
UpdatePullRequestDescriptionError::InvalidPullRequestId(err.msg),
)
}
"PullRequestAlreadyClosedException" => {
return RusotoError::Service(
UpdatePullRequestDescriptionError::PullRequestAlreadyClosed(err.msg),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
UpdatePullRequestDescriptionError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
UpdatePullRequestDescriptionError::PullRequestIdRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdatePullRequestDescriptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdatePullRequestDescriptionError::InvalidDescription(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestDescriptionError::InvalidPullRequestId(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestDescriptionError::PullRequestAlreadyClosed(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestDescriptionError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestDescriptionError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdatePullRequestDescriptionError {}
#[derive(Debug, PartialEq)]
pub enum UpdatePullRequestStatusError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidPullRequestId(String),
InvalidPullRequestStatus(String),
InvalidPullRequestStatusUpdate(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
PullRequestStatusRequired(String),
}
impl UpdatePullRequestStatusError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdatePullRequestStatusError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
UpdatePullRequestStatusError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
UpdatePullRequestStatusError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
UpdatePullRequestStatusError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
UpdatePullRequestStatusError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
UpdatePullRequestStatusError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidPullRequestIdException" => {
return RusotoError::Service(
UpdatePullRequestStatusError::InvalidPullRequestId(err.msg),
)
}
"InvalidPullRequestStatusException" => {
return RusotoError::Service(
UpdatePullRequestStatusError::InvalidPullRequestStatus(err.msg),
)
}
"InvalidPullRequestStatusUpdateException" => {
return RusotoError::Service(
UpdatePullRequestStatusError::InvalidPullRequestStatusUpdate(err.msg),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
UpdatePullRequestStatusError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
UpdatePullRequestStatusError::PullRequestIdRequired(err.msg),
)
}
"PullRequestStatusRequiredException" => {
return RusotoError::Service(
UpdatePullRequestStatusError::PullRequestStatusRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdatePullRequestStatusError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdatePullRequestStatusError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestStatusError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestStatusError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestStatusError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestStatusError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestStatusError::InvalidPullRequestId(ref cause) => write!(f, "{}", cause),
UpdatePullRequestStatusError::InvalidPullRequestStatus(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestStatusError::InvalidPullRequestStatusUpdate(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestStatusError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestStatusError::PullRequestIdRequired(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestStatusError::PullRequestStatusRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdatePullRequestStatusError {}
#[derive(Debug, PartialEq)]
pub enum UpdatePullRequestTitleError {
InvalidPullRequestId(String),
InvalidTitle(String),
PullRequestAlreadyClosed(String),
PullRequestDoesNotExist(String),
PullRequestIdRequired(String),
TitleRequired(String),
}
impl UpdatePullRequestTitleError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdatePullRequestTitleError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidPullRequestIdException" => {
return RusotoError::Service(UpdatePullRequestTitleError::InvalidPullRequestId(
err.msg,
))
}
"InvalidTitleException" => {
return RusotoError::Service(UpdatePullRequestTitleError::InvalidTitle(err.msg))
}
"PullRequestAlreadyClosedException" => {
return RusotoError::Service(
UpdatePullRequestTitleError::PullRequestAlreadyClosed(err.msg),
)
}
"PullRequestDoesNotExistException" => {
return RusotoError::Service(
UpdatePullRequestTitleError::PullRequestDoesNotExist(err.msg),
)
}
"PullRequestIdRequiredException" => {
return RusotoError::Service(
UpdatePullRequestTitleError::PullRequestIdRequired(err.msg),
)
}
"TitleRequiredException" => {
return RusotoError::Service(UpdatePullRequestTitleError::TitleRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdatePullRequestTitleError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdatePullRequestTitleError::InvalidPullRequestId(ref cause) => write!(f, "{}", cause),
UpdatePullRequestTitleError::InvalidTitle(ref cause) => write!(f, "{}", cause),
UpdatePullRequestTitleError::PullRequestAlreadyClosed(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestTitleError::PullRequestDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdatePullRequestTitleError::PullRequestIdRequired(ref cause) => write!(f, "{}", cause),
UpdatePullRequestTitleError::TitleRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdatePullRequestTitleError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRepositoryDescriptionError {
EncryptionIntegrityChecksFailed(String),
EncryptionKeyAccessDenied(String),
EncryptionKeyDisabled(String),
EncryptionKeyNotFound(String),
EncryptionKeyUnavailable(String),
InvalidRepositoryDescription(String),
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameRequired(String),
}
impl UpdateRepositoryDescriptionError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<UpdateRepositoryDescriptionError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"EncryptionIntegrityChecksFailedException" => {
return RusotoError::Service(
UpdateRepositoryDescriptionError::EncryptionIntegrityChecksFailed(err.msg),
)
}
"EncryptionKeyAccessDeniedException" => {
return RusotoError::Service(
UpdateRepositoryDescriptionError::EncryptionKeyAccessDenied(err.msg),
)
}
"EncryptionKeyDisabledException" => {
return RusotoError::Service(
UpdateRepositoryDescriptionError::EncryptionKeyDisabled(err.msg),
)
}
"EncryptionKeyNotFoundException" => {
return RusotoError::Service(
UpdateRepositoryDescriptionError::EncryptionKeyNotFound(err.msg),
)
}
"EncryptionKeyUnavailableException" => {
return RusotoError::Service(
UpdateRepositoryDescriptionError::EncryptionKeyUnavailable(err.msg),
)
}
"InvalidRepositoryDescriptionException" => {
return RusotoError::Service(
UpdateRepositoryDescriptionError::InvalidRepositoryDescription(err.msg),
)
}
"InvalidRepositoryNameException" => {
return RusotoError::Service(
UpdateRepositoryDescriptionError::InvalidRepositoryName(err.msg),
)
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(
UpdateRepositoryDescriptionError::RepositoryDoesNotExist(err.msg),
)
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(
UpdateRepositoryDescriptionError::RepositoryNameRequired(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRepositoryDescriptionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRepositoryDescriptionError::EncryptionIntegrityChecksFailed(ref cause) => {
write!(f, "{}", cause)
}
UpdateRepositoryDescriptionError::EncryptionKeyAccessDenied(ref cause) => {
write!(f, "{}", cause)
}
UpdateRepositoryDescriptionError::EncryptionKeyDisabled(ref cause) => {
write!(f, "{}", cause)
}
UpdateRepositoryDescriptionError::EncryptionKeyNotFound(ref cause) => {
write!(f, "{}", cause)
}
UpdateRepositoryDescriptionError::EncryptionKeyUnavailable(ref cause) => {
write!(f, "{}", cause)
}
UpdateRepositoryDescriptionError::InvalidRepositoryDescription(ref cause) => {
write!(f, "{}", cause)
}
UpdateRepositoryDescriptionError::InvalidRepositoryName(ref cause) => {
write!(f, "{}", cause)
}
UpdateRepositoryDescriptionError::RepositoryDoesNotExist(ref cause) => {
write!(f, "{}", cause)
}
UpdateRepositoryDescriptionError::RepositoryNameRequired(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for UpdateRepositoryDescriptionError {}
#[derive(Debug, PartialEq)]
pub enum UpdateRepositoryNameError {
InvalidRepositoryName(String),
RepositoryDoesNotExist(String),
RepositoryNameExists(String),
RepositoryNameRequired(String),
}
impl UpdateRepositoryNameError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateRepositoryNameError> {
if let Some(err) = proto::json::Error::parse(&res) {
match err.typ.as_str() {
"InvalidRepositoryNameException" => {
return RusotoError::Service(UpdateRepositoryNameError::InvalidRepositoryName(
err.msg,
))
}
"RepositoryDoesNotExistException" => {
return RusotoError::Service(UpdateRepositoryNameError::RepositoryDoesNotExist(
err.msg,
))
}
"RepositoryNameExistsException" => {
return RusotoError::Service(UpdateRepositoryNameError::RepositoryNameExists(
err.msg,
))
}
"RepositoryNameRequiredException" => {
return RusotoError::Service(UpdateRepositoryNameError::RepositoryNameRequired(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateRepositoryNameError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateRepositoryNameError::InvalidRepositoryName(ref cause) => write!(f, "{}", cause),
UpdateRepositoryNameError::RepositoryDoesNotExist(ref cause) => write!(f, "{}", cause),
UpdateRepositoryNameError::RepositoryNameExists(ref cause) => write!(f, "{}", cause),
UpdateRepositoryNameError::RepositoryNameRequired(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateRepositoryNameError {}
#[async_trait]
pub trait CodeCommit {
async fn associate_approval_rule_template_with_repository(
&self,
input: AssociateApprovalRuleTemplateWithRepositoryInput,
) -> Result<(), RusotoError<AssociateApprovalRuleTemplateWithRepositoryError>>;
async fn batch_associate_approval_rule_template_with_repositories(
&self,
input: BatchAssociateApprovalRuleTemplateWithRepositoriesInput,
) -> Result<
BatchAssociateApprovalRuleTemplateWithRepositoriesOutput,
RusotoError<BatchAssociateApprovalRuleTemplateWithRepositoriesError>,
>;
async fn batch_describe_merge_conflicts(
&self,
input: BatchDescribeMergeConflictsInput,
) -> Result<BatchDescribeMergeConflictsOutput, RusotoError<BatchDescribeMergeConflictsError>>;
async fn batch_disassociate_approval_rule_template_from_repositories(
&self,
input: BatchDisassociateApprovalRuleTemplateFromRepositoriesInput,
) -> Result<
BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput,
RusotoError<BatchDisassociateApprovalRuleTemplateFromRepositoriesError>,
>;
async fn batch_get_commits(
&self,
input: BatchGetCommitsInput,
) -> Result<BatchGetCommitsOutput, RusotoError<BatchGetCommitsError>>;
async fn batch_get_repositories(
&self,
input: BatchGetRepositoriesInput,
) -> Result<BatchGetRepositoriesOutput, RusotoError<BatchGetRepositoriesError>>;
async fn create_approval_rule_template(
&self,
input: CreateApprovalRuleTemplateInput,
) -> Result<CreateApprovalRuleTemplateOutput, RusotoError<CreateApprovalRuleTemplateError>>;
async fn create_branch(
&self,
input: CreateBranchInput,
) -> Result<(), RusotoError<CreateBranchError>>;
async fn create_commit(
&self,
input: CreateCommitInput,
) -> Result<CreateCommitOutput, RusotoError<CreateCommitError>>;
async fn create_pull_request(
&self,
input: CreatePullRequestInput,
) -> Result<CreatePullRequestOutput, RusotoError<CreatePullRequestError>>;
async fn create_pull_request_approval_rule(
&self,
input: CreatePullRequestApprovalRuleInput,
) -> Result<CreatePullRequestApprovalRuleOutput, RusotoError<CreatePullRequestApprovalRuleError>>;
async fn create_repository(
&self,
input: CreateRepositoryInput,
) -> Result<CreateRepositoryOutput, RusotoError<CreateRepositoryError>>;
async fn create_unreferenced_merge_commit(
&self,
input: CreateUnreferencedMergeCommitInput,
) -> Result<CreateUnreferencedMergeCommitOutput, RusotoError<CreateUnreferencedMergeCommitError>>;
async fn delete_approval_rule_template(
&self,
input: DeleteApprovalRuleTemplateInput,
) -> Result<DeleteApprovalRuleTemplateOutput, RusotoError<DeleteApprovalRuleTemplateError>>;
async fn delete_branch(
&self,
input: DeleteBranchInput,
) -> Result<DeleteBranchOutput, RusotoError<DeleteBranchError>>;
async fn delete_comment_content(
&self,
input: DeleteCommentContentInput,
) -> Result<DeleteCommentContentOutput, RusotoError<DeleteCommentContentError>>;
async fn delete_file(
&self,
input: DeleteFileInput,
) -> Result<DeleteFileOutput, RusotoError<DeleteFileError>>;
async fn delete_pull_request_approval_rule(
&self,
input: DeletePullRequestApprovalRuleInput,
) -> Result<DeletePullRequestApprovalRuleOutput, RusotoError<DeletePullRequestApprovalRuleError>>;
async fn delete_repository(
&self,
input: DeleteRepositoryInput,
) -> Result<DeleteRepositoryOutput, RusotoError<DeleteRepositoryError>>;
async fn describe_merge_conflicts(
&self,
input: DescribeMergeConflictsInput,
) -> Result<DescribeMergeConflictsOutput, RusotoError<DescribeMergeConflictsError>>;
async fn describe_pull_request_events(
&self,
input: DescribePullRequestEventsInput,
) -> Result<DescribePullRequestEventsOutput, RusotoError<DescribePullRequestEventsError>>;
async fn disassociate_approval_rule_template_from_repository(
&self,
input: DisassociateApprovalRuleTemplateFromRepositoryInput,
) -> Result<(), RusotoError<DisassociateApprovalRuleTemplateFromRepositoryError>>;
async fn evaluate_pull_request_approval_rules(
&self,
input: EvaluatePullRequestApprovalRulesInput,
) -> Result<
EvaluatePullRequestApprovalRulesOutput,
RusotoError<EvaluatePullRequestApprovalRulesError>,
>;
async fn get_approval_rule_template(
&self,
input: GetApprovalRuleTemplateInput,
) -> Result<GetApprovalRuleTemplateOutput, RusotoError<GetApprovalRuleTemplateError>>;
async fn get_blob(
&self,
input: GetBlobInput,
) -> Result<GetBlobOutput, RusotoError<GetBlobError>>;
async fn get_branch(
&self,
input: GetBranchInput,
) -> Result<GetBranchOutput, RusotoError<GetBranchError>>;
async fn get_comment(
&self,
input: GetCommentInput,
) -> Result<GetCommentOutput, RusotoError<GetCommentError>>;
async fn get_comment_reactions(
&self,
input: GetCommentReactionsInput,
) -> Result<GetCommentReactionsOutput, RusotoError<GetCommentReactionsError>>;
async fn get_comments_for_compared_commit(
&self,
input: GetCommentsForComparedCommitInput,
) -> Result<GetCommentsForComparedCommitOutput, RusotoError<GetCommentsForComparedCommitError>>;
async fn get_comments_for_pull_request(
&self,
input: GetCommentsForPullRequestInput,
) -> Result<GetCommentsForPullRequestOutput, RusotoError<GetCommentsForPullRequestError>>;
async fn get_commit(
&self,
input: GetCommitInput,
) -> Result<GetCommitOutput, RusotoError<GetCommitError>>;
async fn get_differences(
&self,
input: GetDifferencesInput,
) -> Result<GetDifferencesOutput, RusotoError<GetDifferencesError>>;
async fn get_file(
&self,
input: GetFileInput,
) -> Result<GetFileOutput, RusotoError<GetFileError>>;
async fn get_folder(
&self,
input: GetFolderInput,
) -> Result<GetFolderOutput, RusotoError<GetFolderError>>;
async fn get_merge_commit(
&self,
input: GetMergeCommitInput,
) -> Result<GetMergeCommitOutput, RusotoError<GetMergeCommitError>>;
async fn get_merge_conflicts(
&self,
input: GetMergeConflictsInput,
) -> Result<GetMergeConflictsOutput, RusotoError<GetMergeConflictsError>>;
async fn get_merge_options(
&self,
input: GetMergeOptionsInput,
) -> Result<GetMergeOptionsOutput, RusotoError<GetMergeOptionsError>>;
async fn get_pull_request(
&self,
input: GetPullRequestInput,
) -> Result<GetPullRequestOutput, RusotoError<GetPullRequestError>>;
async fn get_pull_request_approval_states(
&self,
input: GetPullRequestApprovalStatesInput,
) -> Result<GetPullRequestApprovalStatesOutput, RusotoError<GetPullRequestApprovalStatesError>>;
async fn get_pull_request_override_state(
&self,
input: GetPullRequestOverrideStateInput,
) -> Result<GetPullRequestOverrideStateOutput, RusotoError<GetPullRequestOverrideStateError>>;
async fn get_repository(
&self,
input: GetRepositoryInput,
) -> Result<GetRepositoryOutput, RusotoError<GetRepositoryError>>;
async fn get_repository_triggers(
&self,
input: GetRepositoryTriggersInput,
) -> Result<GetRepositoryTriggersOutput, RusotoError<GetRepositoryTriggersError>>;
async fn list_approval_rule_templates(
&self,
input: ListApprovalRuleTemplatesInput,
) -> Result<ListApprovalRuleTemplatesOutput, RusotoError<ListApprovalRuleTemplatesError>>;
async fn list_associated_approval_rule_templates_for_repository(
&self,
input: ListAssociatedApprovalRuleTemplatesForRepositoryInput,
) -> Result<
ListAssociatedApprovalRuleTemplatesForRepositoryOutput,
RusotoError<ListAssociatedApprovalRuleTemplatesForRepositoryError>,
>;
async fn list_branches(
&self,
input: ListBranchesInput,
) -> Result<ListBranchesOutput, RusotoError<ListBranchesError>>;
async fn list_pull_requests(
&self,
input: ListPullRequestsInput,
) -> Result<ListPullRequestsOutput, RusotoError<ListPullRequestsError>>;
async fn list_repositories(
&self,
input: ListRepositoriesInput,
) -> Result<ListRepositoriesOutput, RusotoError<ListRepositoriesError>>;
async fn list_repositories_for_approval_rule_template(
&self,
input: ListRepositoriesForApprovalRuleTemplateInput,
) -> Result<
ListRepositoriesForApprovalRuleTemplateOutput,
RusotoError<ListRepositoriesForApprovalRuleTemplateError>,
>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>>;
async fn merge_branches_by_fast_forward(
&self,
input: MergeBranchesByFastForwardInput,
) -> Result<MergeBranchesByFastForwardOutput, RusotoError<MergeBranchesByFastForwardError>>;
async fn merge_branches_by_squash(
&self,
input: MergeBranchesBySquashInput,
) -> Result<MergeBranchesBySquashOutput, RusotoError<MergeBranchesBySquashError>>;
async fn merge_branches_by_three_way(
&self,
input: MergeBranchesByThreeWayInput,
) -> Result<MergeBranchesByThreeWayOutput, RusotoError<MergeBranchesByThreeWayError>>;
async fn merge_pull_request_by_fast_forward(
&self,
input: MergePullRequestByFastForwardInput,
) -> Result<MergePullRequestByFastForwardOutput, RusotoError<MergePullRequestByFastForwardError>>;
async fn merge_pull_request_by_squash(
&self,
input: MergePullRequestBySquashInput,
) -> Result<MergePullRequestBySquashOutput, RusotoError<MergePullRequestBySquashError>>;
async fn merge_pull_request_by_three_way(
&self,
input: MergePullRequestByThreeWayInput,
) -> Result<MergePullRequestByThreeWayOutput, RusotoError<MergePullRequestByThreeWayError>>;
async fn override_pull_request_approval_rules(
&self,
input: OverridePullRequestApprovalRulesInput,
) -> Result<(), RusotoError<OverridePullRequestApprovalRulesError>>;
async fn post_comment_for_compared_commit(
&self,
input: PostCommentForComparedCommitInput,
) -> Result<PostCommentForComparedCommitOutput, RusotoError<PostCommentForComparedCommitError>>;
async fn post_comment_for_pull_request(
&self,
input: PostCommentForPullRequestInput,
) -> Result<PostCommentForPullRequestOutput, RusotoError<PostCommentForPullRequestError>>;
async fn post_comment_reply(
&self,
input: PostCommentReplyInput,
) -> Result<PostCommentReplyOutput, RusotoError<PostCommentReplyError>>;
async fn put_comment_reaction(
&self,
input: PutCommentReactionInput,
) -> Result<(), RusotoError<PutCommentReactionError>>;
async fn put_file(
&self,
input: PutFileInput,
) -> Result<PutFileOutput, RusotoError<PutFileError>>;
async fn put_repository_triggers(
&self,
input: PutRepositoryTriggersInput,
) -> Result<PutRepositoryTriggersOutput, RusotoError<PutRepositoryTriggersError>>;
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<(), RusotoError<TagResourceError>>;
async fn test_repository_triggers(
&self,
input: TestRepositoryTriggersInput,
) -> Result<TestRepositoryTriggersOutput, RusotoError<TestRepositoryTriggersError>>;
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<(), RusotoError<UntagResourceError>>;
async fn update_approval_rule_template_content(
&self,
input: UpdateApprovalRuleTemplateContentInput,
) -> Result<
UpdateApprovalRuleTemplateContentOutput,
RusotoError<UpdateApprovalRuleTemplateContentError>,
>;
async fn update_approval_rule_template_description(
&self,
input: UpdateApprovalRuleTemplateDescriptionInput,
) -> Result<
UpdateApprovalRuleTemplateDescriptionOutput,
RusotoError<UpdateApprovalRuleTemplateDescriptionError>,
>;
async fn update_approval_rule_template_name(
&self,
input: UpdateApprovalRuleTemplateNameInput,
) -> Result<
UpdateApprovalRuleTemplateNameOutput,
RusotoError<UpdateApprovalRuleTemplateNameError>,
>;
async fn update_comment(
&self,
input: UpdateCommentInput,
) -> Result<UpdateCommentOutput, RusotoError<UpdateCommentError>>;
async fn update_default_branch(
&self,
input: UpdateDefaultBranchInput,
) -> Result<(), RusotoError<UpdateDefaultBranchError>>;
async fn update_pull_request_approval_rule_content(
&self,
input: UpdatePullRequestApprovalRuleContentInput,
) -> Result<
UpdatePullRequestApprovalRuleContentOutput,
RusotoError<UpdatePullRequestApprovalRuleContentError>,
>;
async fn update_pull_request_approval_state(
&self,
input: UpdatePullRequestApprovalStateInput,
) -> Result<(), RusotoError<UpdatePullRequestApprovalStateError>>;
async fn update_pull_request_description(
&self,
input: UpdatePullRequestDescriptionInput,
) -> Result<UpdatePullRequestDescriptionOutput, RusotoError<UpdatePullRequestDescriptionError>>;
async fn update_pull_request_status(
&self,
input: UpdatePullRequestStatusInput,
) -> Result<UpdatePullRequestStatusOutput, RusotoError<UpdatePullRequestStatusError>>;
async fn update_pull_request_title(
&self,
input: UpdatePullRequestTitleInput,
) -> Result<UpdatePullRequestTitleOutput, RusotoError<UpdatePullRequestTitleError>>;
async fn update_repository_description(
&self,
input: UpdateRepositoryDescriptionInput,
) -> Result<(), RusotoError<UpdateRepositoryDescriptionError>>;
async fn update_repository_name(
&self,
input: UpdateRepositoryNameInput,
) -> Result<(), RusotoError<UpdateRepositoryNameError>>;
}
#[derive(Clone)]
pub struct CodeCommitClient {
client: Client,
region: region::Region,
}
impl CodeCommitClient {
pub fn new(region: region::Region) -> CodeCommitClient {
CodeCommitClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CodeCommitClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CodeCommitClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> CodeCommitClient {
CodeCommitClient { client, region }
}
}
#[async_trait]
impl CodeCommit for CodeCommitClient {
async fn associate_approval_rule_template_with_repository(
&self,
input: AssociateApprovalRuleTemplateWithRepositoryInput,
) -> Result<(), RusotoError<AssociateApprovalRuleTemplateWithRepositoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.AssociateApprovalRuleTemplateWithRepository",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
AssociateApprovalRuleTemplateWithRepositoryError::from_response,
)
.await?;
std::mem::drop(response);
Ok(())
}
async fn batch_associate_approval_rule_template_with_repositories(
&self,
input: BatchAssociateApprovalRuleTemplateWithRepositoriesInput,
) -> Result<
BatchAssociateApprovalRuleTemplateWithRepositoriesOutput,
RusotoError<BatchAssociateApprovalRuleTemplateWithRepositoriesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.BatchAssociateApprovalRuleTemplateWithRepositories",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
BatchAssociateApprovalRuleTemplateWithRepositoriesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchAssociateApprovalRuleTemplateWithRepositoriesOutput, _>()
}
async fn batch_describe_merge_conflicts(
&self,
input: BatchDescribeMergeConflictsInput,
) -> Result<BatchDescribeMergeConflictsOutput, RusotoError<BatchDescribeMergeConflictsError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.BatchDescribeMergeConflicts",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchDescribeMergeConflictsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchDescribeMergeConflictsOutput, _>()
}
async fn batch_disassociate_approval_rule_template_from_repositories(
&self,
input: BatchDisassociateApprovalRuleTemplateFromRepositoriesInput,
) -> Result<
BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput,
RusotoError<BatchDisassociateApprovalRuleTemplateFromRepositoriesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.BatchDisassociateApprovalRuleTemplateFromRepositories",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
BatchDisassociateApprovalRuleTemplateFromRepositoriesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<BatchDisassociateApprovalRuleTemplateFromRepositoriesOutput, _>()
}
async fn batch_get_commits(
&self,
input: BatchGetCommitsInput,
) -> Result<BatchGetCommitsOutput, RusotoError<BatchGetCommitsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.BatchGetCommits");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetCommitsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<BatchGetCommitsOutput, _>()
}
async fn batch_get_repositories(
&self,
input: BatchGetRepositoriesInput,
) -> Result<BatchGetRepositoriesOutput, RusotoError<BatchGetRepositoriesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.BatchGetRepositories");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, BatchGetRepositoriesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<BatchGetRepositoriesOutput, _>()
}
async fn create_approval_rule_template(
&self,
input: CreateApprovalRuleTemplateInput,
) -> Result<CreateApprovalRuleTemplateOutput, RusotoError<CreateApprovalRuleTemplateError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.CreateApprovalRuleTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateApprovalRuleTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateApprovalRuleTemplateOutput, _>()
}
async fn create_branch(
&self,
input: CreateBranchInput,
) -> Result<(), RusotoError<CreateBranchError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.CreateBranch");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateBranchError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn create_commit(
&self,
input: CreateCommitInput,
) -> Result<CreateCommitOutput, RusotoError<CreateCommitError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.CreateCommit");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateCommitError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateCommitOutput, _>()
}
async fn create_pull_request(
&self,
input: CreatePullRequestInput,
) -> Result<CreatePullRequestOutput, RusotoError<CreatePullRequestError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.CreatePullRequest");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreatePullRequestError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreatePullRequestOutput, _>()
}
async fn create_pull_request_approval_rule(
&self,
input: CreatePullRequestApprovalRuleInput,
) -> Result<CreatePullRequestApprovalRuleOutput, RusotoError<CreatePullRequestApprovalRuleError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.CreatePullRequestApprovalRule",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreatePullRequestApprovalRuleError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreatePullRequestApprovalRuleOutput, _>()
}
async fn create_repository(
&self,
input: CreateRepositoryInput,
) -> Result<CreateRepositoryOutput, RusotoError<CreateRepositoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.CreateRepository");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateRepositoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<CreateRepositoryOutput, _>()
}
async fn create_unreferenced_merge_commit(
&self,
input: CreateUnreferencedMergeCommitInput,
) -> Result<CreateUnreferencedMergeCommitOutput, RusotoError<CreateUnreferencedMergeCommitError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.CreateUnreferencedMergeCommit",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, CreateUnreferencedMergeCommitError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<CreateUnreferencedMergeCommitOutput, _>()
}
async fn delete_approval_rule_template(
&self,
input: DeleteApprovalRuleTemplateInput,
) -> Result<DeleteApprovalRuleTemplateOutput, RusotoError<DeleteApprovalRuleTemplateError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.DeleteApprovalRuleTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteApprovalRuleTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteApprovalRuleTemplateOutput, _>()
}
async fn delete_branch(
&self,
input: DeleteBranchInput,
) -> Result<DeleteBranchOutput, RusotoError<DeleteBranchError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.DeleteBranch");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteBranchError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteBranchOutput, _>()
}
async fn delete_comment_content(
&self,
input: DeleteCommentContentInput,
) -> Result<DeleteCommentContentOutput, RusotoError<DeleteCommentContentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.DeleteCommentContent");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteCommentContentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteCommentContentOutput, _>()
}
async fn delete_file(
&self,
input: DeleteFileInput,
) -> Result<DeleteFileOutput, RusotoError<DeleteFileError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.DeleteFile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteFileError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteFileOutput, _>()
}
async fn delete_pull_request_approval_rule(
&self,
input: DeletePullRequestApprovalRuleInput,
) -> Result<DeletePullRequestApprovalRuleOutput, RusotoError<DeletePullRequestApprovalRuleError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.DeletePullRequestApprovalRule",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeletePullRequestApprovalRuleError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DeletePullRequestApprovalRuleOutput, _>()
}
async fn delete_repository(
&self,
input: DeleteRepositoryInput,
) -> Result<DeleteRepositoryOutput, RusotoError<DeleteRepositoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.DeleteRepository");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DeleteRepositoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<DeleteRepositoryOutput, _>()
}
async fn describe_merge_conflicts(
&self,
input: DescribeMergeConflictsInput,
) -> Result<DescribeMergeConflictsOutput, RusotoError<DescribeMergeConflictsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.DescribeMergeConflicts");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribeMergeConflictsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribeMergeConflictsOutput, _>()
}
async fn describe_pull_request_events(
&self,
input: DescribePullRequestEventsInput,
) -> Result<DescribePullRequestEventsOutput, RusotoError<DescribePullRequestEventsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.DescribePullRequestEvents",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, DescribePullRequestEventsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<DescribePullRequestEventsOutput, _>()
}
async fn disassociate_approval_rule_template_from_repository(
&self,
input: DisassociateApprovalRuleTemplateFromRepositoryInput,
) -> Result<(), RusotoError<DisassociateApprovalRuleTemplateFromRepositoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.DisassociateApprovalRuleTemplateFromRepository",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
DisassociateApprovalRuleTemplateFromRepositoryError::from_response,
)
.await?;
std::mem::drop(response);
Ok(())
}
async fn evaluate_pull_request_approval_rules(
&self,
input: EvaluatePullRequestApprovalRulesInput,
) -> Result<
EvaluatePullRequestApprovalRulesOutput,
RusotoError<EvaluatePullRequestApprovalRulesError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.EvaluatePullRequestApprovalRules",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
EvaluatePullRequestApprovalRulesError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<EvaluatePullRequestApprovalRulesOutput, _>()
}
async fn get_approval_rule_template(
&self,
input: GetApprovalRuleTemplateInput,
) -> Result<GetApprovalRuleTemplateOutput, RusotoError<GetApprovalRuleTemplateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.GetApprovalRuleTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetApprovalRuleTemplateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetApprovalRuleTemplateOutput, _>()
}
async fn get_blob(
&self,
input: GetBlobInput,
) -> Result<GetBlobOutput, RusotoError<GetBlobError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetBlob");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetBlobError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetBlobOutput, _>()
}
async fn get_branch(
&self,
input: GetBranchInput,
) -> Result<GetBranchOutput, RusotoError<GetBranchError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetBranch");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetBranchError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetBranchOutput, _>()
}
async fn get_comment(
&self,
input: GetCommentInput,
) -> Result<GetCommentOutput, RusotoError<GetCommentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetComment");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetCommentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetCommentOutput, _>()
}
async fn get_comment_reactions(
&self,
input: GetCommentReactionsInput,
) -> Result<GetCommentReactionsOutput, RusotoError<GetCommentReactionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetCommentReactions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetCommentReactionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetCommentReactionsOutput, _>()
}
async fn get_comments_for_compared_commit(
&self,
input: GetCommentsForComparedCommitInput,
) -> Result<GetCommentsForComparedCommitOutput, RusotoError<GetCommentsForComparedCommitError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.GetCommentsForComparedCommit",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetCommentsForComparedCommitError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetCommentsForComparedCommitOutput, _>()
}
async fn get_comments_for_pull_request(
&self,
input: GetCommentsForPullRequestInput,
) -> Result<GetCommentsForPullRequestOutput, RusotoError<GetCommentsForPullRequestError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.GetCommentsForPullRequest",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetCommentsForPullRequestError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetCommentsForPullRequestOutput, _>()
}
async fn get_commit(
&self,
input: GetCommitInput,
) -> Result<GetCommitOutput, RusotoError<GetCommitError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetCommit");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetCommitError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetCommitOutput, _>()
}
async fn get_differences(
&self,
input: GetDifferencesInput,
) -> Result<GetDifferencesOutput, RusotoError<GetDifferencesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetDifferences");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetDifferencesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetDifferencesOutput, _>()
}
async fn get_file(
&self,
input: GetFileInput,
) -> Result<GetFileOutput, RusotoError<GetFileError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetFile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetFileError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetFileOutput, _>()
}
async fn get_folder(
&self,
input: GetFolderInput,
) -> Result<GetFolderOutput, RusotoError<GetFolderError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetFolder");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetFolderError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetFolderOutput, _>()
}
async fn get_merge_commit(
&self,
input: GetMergeCommitInput,
) -> Result<GetMergeCommitOutput, RusotoError<GetMergeCommitError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetMergeCommit");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetMergeCommitError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetMergeCommitOutput, _>()
}
async fn get_merge_conflicts(
&self,
input: GetMergeConflictsInput,
) -> Result<GetMergeConflictsOutput, RusotoError<GetMergeConflictsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetMergeConflicts");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetMergeConflictsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetMergeConflictsOutput, _>()
}
async fn get_merge_options(
&self,
input: GetMergeOptionsInput,
) -> Result<GetMergeOptionsOutput, RusotoError<GetMergeOptionsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetMergeOptions");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetMergeOptionsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetMergeOptionsOutput, _>()
}
async fn get_pull_request(
&self,
input: GetPullRequestInput,
) -> Result<GetPullRequestOutput, RusotoError<GetPullRequestError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetPullRequest");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetPullRequestError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetPullRequestOutput, _>()
}
async fn get_pull_request_approval_states(
&self,
input: GetPullRequestApprovalStatesInput,
) -> Result<GetPullRequestApprovalStatesOutput, RusotoError<GetPullRequestApprovalStatesError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.GetPullRequestApprovalStates",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetPullRequestApprovalStatesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetPullRequestApprovalStatesOutput, _>()
}
async fn get_pull_request_override_state(
&self,
input: GetPullRequestOverrideStateInput,
) -> Result<GetPullRequestOverrideStateOutput, RusotoError<GetPullRequestOverrideStateError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.GetPullRequestOverrideState",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetPullRequestOverrideStateError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<GetPullRequestOverrideStateOutput, _>()
}
async fn get_repository(
&self,
input: GetRepositoryInput,
) -> Result<GetRepositoryOutput, RusotoError<GetRepositoryError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetRepository");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRepositoryError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetRepositoryOutput, _>()
}
async fn get_repository_triggers(
&self,
input: GetRepositoryTriggersInput,
) -> Result<GetRepositoryTriggersOutput, RusotoError<GetRepositoryTriggersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.GetRepositoryTriggers");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, GetRepositoryTriggersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<GetRepositoryTriggersOutput, _>()
}
async fn list_approval_rule_templates(
&self,
input: ListApprovalRuleTemplatesInput,
) -> Result<ListApprovalRuleTemplatesOutput, RusotoError<ListApprovalRuleTemplatesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.ListApprovalRuleTemplates",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListApprovalRuleTemplatesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListApprovalRuleTemplatesOutput, _>()
}
async fn list_associated_approval_rule_templates_for_repository(
&self,
input: ListAssociatedApprovalRuleTemplatesForRepositoryInput,
) -> Result<
ListAssociatedApprovalRuleTemplatesForRepositoryOutput,
RusotoError<ListAssociatedApprovalRuleTemplatesForRepositoryError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.ListAssociatedApprovalRuleTemplatesForRepository",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListAssociatedApprovalRuleTemplatesForRepositoryError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListAssociatedApprovalRuleTemplatesForRepositoryOutput, _>()
}
async fn list_branches(
&self,
input: ListBranchesInput,
) -> Result<ListBranchesOutput, RusotoError<ListBranchesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.ListBranches");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListBranchesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListBranchesOutput, _>()
}
async fn list_pull_requests(
&self,
input: ListPullRequestsInput,
) -> Result<ListPullRequestsOutput, RusotoError<ListPullRequestsError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.ListPullRequests");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListPullRequestsError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListPullRequestsOutput, _>()
}
async fn list_repositories(
&self,
input: ListRepositoriesInput,
) -> Result<ListRepositoriesOutput, RusotoError<ListRepositoriesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.ListRepositories");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListRepositoriesError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListRepositoriesOutput, _>()
}
async fn list_repositories_for_approval_rule_template(
&self,
input: ListRepositoriesForApprovalRuleTemplateInput,
) -> Result<
ListRepositoriesForApprovalRuleTemplateOutput,
RusotoError<ListRepositoriesForApprovalRuleTemplateError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.ListRepositoriesForApprovalRuleTemplate",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
ListRepositoriesForApprovalRuleTemplateError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<ListRepositoriesForApprovalRuleTemplateOutput, _>()
}
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceInput,
) -> Result<ListTagsForResourceOutput, RusotoError<ListTagsForResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.ListTagsForResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, ListTagsForResourceError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<ListTagsForResourceOutput, _>()
}
async fn merge_branches_by_fast_forward(
&self,
input: MergeBranchesByFastForwardInput,
) -> Result<MergeBranchesByFastForwardOutput, RusotoError<MergeBranchesByFastForwardError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.MergeBranchesByFastForward",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, MergeBranchesByFastForwardError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<MergeBranchesByFastForwardOutput, _>()
}
async fn merge_branches_by_squash(
&self,
input: MergeBranchesBySquashInput,
) -> Result<MergeBranchesBySquashOutput, RusotoError<MergeBranchesBySquashError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.MergeBranchesBySquash");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, MergeBranchesBySquashError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<MergeBranchesBySquashOutput, _>()
}
async fn merge_branches_by_three_way(
&self,
input: MergeBranchesByThreeWayInput,
) -> Result<MergeBranchesByThreeWayOutput, RusotoError<MergeBranchesByThreeWayError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.MergeBranchesByThreeWay",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, MergeBranchesByThreeWayError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<MergeBranchesByThreeWayOutput, _>()
}
async fn merge_pull_request_by_fast_forward(
&self,
input: MergePullRequestByFastForwardInput,
) -> Result<MergePullRequestByFastForwardOutput, RusotoError<MergePullRequestByFastForwardError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.MergePullRequestByFastForward",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, MergePullRequestByFastForwardError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<MergePullRequestByFastForwardOutput, _>()
}
async fn merge_pull_request_by_squash(
&self,
input: MergePullRequestBySquashInput,
) -> Result<MergePullRequestBySquashOutput, RusotoError<MergePullRequestBySquashError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.MergePullRequestBySquash",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, MergePullRequestBySquashError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<MergePullRequestBySquashOutput, _>()
}
async fn merge_pull_request_by_three_way(
&self,
input: MergePullRequestByThreeWayInput,
) -> Result<MergePullRequestByThreeWayOutput, RusotoError<MergePullRequestByThreeWayError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.MergePullRequestByThreeWay",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, MergePullRequestByThreeWayError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<MergePullRequestByThreeWayOutput, _>()
}
async fn override_pull_request_approval_rules(
&self,
input: OverridePullRequestApprovalRulesInput,
) -> Result<(), RusotoError<OverridePullRequestApprovalRulesError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.OverridePullRequestApprovalRules",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
OverridePullRequestApprovalRulesError::from_response,
)
.await?;
std::mem::drop(response);
Ok(())
}
async fn post_comment_for_compared_commit(
&self,
input: PostCommentForComparedCommitInput,
) -> Result<PostCommentForComparedCommitOutput, RusotoError<PostCommentForComparedCommitError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.PostCommentForComparedCommit",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PostCommentForComparedCommitError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PostCommentForComparedCommitOutput, _>()
}
async fn post_comment_for_pull_request(
&self,
input: PostCommentForPullRequestInput,
) -> Result<PostCommentForPullRequestOutput, RusotoError<PostCommentForPullRequestError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.PostCommentForPullRequest",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PostCommentForPullRequestError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<PostCommentForPullRequestOutput, _>()
}
async fn post_comment_reply(
&self,
input: PostCommentReplyInput,
) -> Result<PostCommentReplyOutput, RusotoError<PostCommentReplyError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.PostCommentReply");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PostCommentReplyError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<PostCommentReplyOutput, _>()
}
async fn put_comment_reaction(
&self,
input: PutCommentReactionInput,
) -> Result<(), RusotoError<PutCommentReactionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.PutCommentReaction");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutCommentReactionError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn put_file(
&self,
input: PutFileInput,
) -> Result<PutFileOutput, RusotoError<PutFileError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.PutFile");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutFileError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<PutFileOutput, _>()
}
async fn put_repository_triggers(
&self,
input: PutRepositoryTriggersInput,
) -> Result<PutRepositoryTriggersOutput, RusotoError<PutRepositoryTriggersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.PutRepositoryTriggers");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, PutRepositoryTriggersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<PutRepositoryTriggersOutput, _>()
}
async fn tag_resource(
&self,
input: TagResourceInput,
) -> Result<(), RusotoError<TagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.TagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TagResourceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn test_repository_triggers(
&self,
input: TestRepositoryTriggersInput,
) -> Result<TestRepositoryTriggersOutput, RusotoError<TestRepositoryTriggersError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.TestRepositoryTriggers");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, TestRepositoryTriggersError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<TestRepositoryTriggersOutput, _>()
}
async fn untag_resource(
&self,
input: UntagResourceInput,
) -> Result<(), RusotoError<UntagResourceError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.UntagResource");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UntagResourceError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn update_approval_rule_template_content(
&self,
input: UpdateApprovalRuleTemplateContentInput,
) -> Result<
UpdateApprovalRuleTemplateContentOutput,
RusotoError<UpdateApprovalRuleTemplateContentError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.UpdateApprovalRuleTemplateContent",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
UpdateApprovalRuleTemplateContentError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateApprovalRuleTemplateContentOutput, _>()
}
async fn update_approval_rule_template_description(
&self,
input: UpdateApprovalRuleTemplateDescriptionInput,
) -> Result<
UpdateApprovalRuleTemplateDescriptionOutput,
RusotoError<UpdateApprovalRuleTemplateDescriptionError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.UpdateApprovalRuleTemplateDescription",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
UpdateApprovalRuleTemplateDescriptionError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateApprovalRuleTemplateDescriptionOutput, _>()
}
async fn update_approval_rule_template_name(
&self,
input: UpdateApprovalRuleTemplateNameInput,
) -> Result<
UpdateApprovalRuleTemplateNameOutput,
RusotoError<UpdateApprovalRuleTemplateNameError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.UpdateApprovalRuleTemplateName",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateApprovalRuleTemplateNameError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateApprovalRuleTemplateNameOutput, _>()
}
async fn update_comment(
&self,
input: UpdateCommentInput,
) -> Result<UpdateCommentOutput, RusotoError<UpdateCommentError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.UpdateComment");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateCommentError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response).deserialize::<UpdateCommentOutput, _>()
}
async fn update_default_branch(
&self,
input: UpdateDefaultBranchInput,
) -> Result<(), RusotoError<UpdateDefaultBranchError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.UpdateDefaultBranch");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateDefaultBranchError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn update_pull_request_approval_rule_content(
&self,
input: UpdatePullRequestApprovalRuleContentInput,
) -> Result<
UpdatePullRequestApprovalRuleContentOutput,
RusotoError<UpdatePullRequestApprovalRuleContentError>,
> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.UpdatePullRequestApprovalRuleContent",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(
request,
UpdatePullRequestApprovalRuleContentError::from_response,
)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdatePullRequestApprovalRuleContentOutput, _>()
}
async fn update_pull_request_approval_state(
&self,
input: UpdatePullRequestApprovalStateInput,
) -> Result<(), RusotoError<UpdatePullRequestApprovalStateError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.UpdatePullRequestApprovalState",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdatePullRequestApprovalStateError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn update_pull_request_description(
&self,
input: UpdatePullRequestDescriptionInput,
) -> Result<UpdatePullRequestDescriptionOutput, RusotoError<UpdatePullRequestDescriptionError>>
{
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.UpdatePullRequestDescription",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdatePullRequestDescriptionError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdatePullRequestDescriptionOutput, _>()
}
async fn update_pull_request_status(
&self,
input: UpdatePullRequestStatusInput,
) -> Result<UpdatePullRequestStatusOutput, RusotoError<UpdatePullRequestStatusError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.UpdatePullRequestStatus",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdatePullRequestStatusError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdatePullRequestStatusOutput, _>()
}
async fn update_pull_request_title(
&self,
input: UpdatePullRequestTitleInput,
) -> Result<UpdatePullRequestTitleOutput, RusotoError<UpdatePullRequestTitleError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.UpdatePullRequestTitle");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdatePullRequestTitleError::from_response)
.await?;
let mut response = response;
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
proto::json::ResponsePayload::new(&response)
.deserialize::<UpdatePullRequestTitleOutput, _>()
}
async fn update_repository_description(
&self,
input: UpdateRepositoryDescriptionInput,
) -> Result<(), RusotoError<UpdateRepositoryDescriptionError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header(
"x-amz-target",
"CodeCommit_20150413.UpdateRepositoryDescription",
);
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateRepositoryDescriptionError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
async fn update_repository_name(
&self,
input: UpdateRepositoryNameInput,
) -> Result<(), RusotoError<UpdateRepositoryNameError>> {
let mut request = self.new_signed_request("POST", "/");
request.add_header("x-amz-target", "CodeCommit_20150413.UpdateRepositoryName");
let encoded = serde_json::to_string(&input).unwrap();
request.set_payload(Some(encoded));
let response = self
.sign_and_dispatch(request, UpdateRepositoryNameError::from_response)
.await?;
std::mem::drop(response);
Ok(())
}
}