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::signature::SignedRequest;
#[allow(unused_imports)]
use serde::{Deserialize, Serialize};
use serde_json;
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AddFacetToObjectRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "ObjectAttributeList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_attribute_list: Option<Vec<AttributeKeyAndValue>>,
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
#[serde(rename = "SchemaFacet")]
pub schema_facet: SchemaFacet,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AddFacetToObjectResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ApplySchemaRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "PublishedSchemaArn")]
pub published_schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ApplySchemaResponse {
#[serde(rename = "AppliedSchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub applied_schema_arn: Option<String>,
#[serde(rename = "DirectoryArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AttachObjectRequest {
#[serde(rename = "ChildReference")]
pub child_reference: ObjectReference,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "LinkName")]
pub link_name: String,
#[serde(rename = "ParentReference")]
pub parent_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AttachObjectResponse {
#[serde(rename = "AttachedObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attached_object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AttachPolicyRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
#[serde(rename = "PolicyReference")]
pub policy_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AttachPolicyResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AttachToIndexRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "IndexReference")]
pub index_reference: ObjectReference,
#[serde(rename = "TargetReference")]
pub target_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AttachToIndexResponse {
#[serde(rename = "AttachedObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attached_object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct AttachTypedLinkRequest {
#[serde(rename = "Attributes")]
pub attributes: Vec<AttributeNameAndValue>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "SourceObjectReference")]
pub source_object_reference: ObjectReference,
#[serde(rename = "TargetObjectReference")]
pub target_object_reference: ObjectReference,
#[serde(rename = "TypedLinkFacet")]
pub typed_link_facet: TypedLinkSchemaAndFacetName,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct AttachTypedLinkResponse {
#[serde(rename = "TypedLinkSpecifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub typed_link_specifier: Option<TypedLinkSpecifier>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AttributeKey {
#[serde(rename = "FacetName")]
pub facet_name: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AttributeKeyAndValue {
#[serde(rename = "Key")]
pub key: AttributeKey,
#[serde(rename = "Value")]
pub value: TypedAttributeValue,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct AttributeNameAndValue {
#[serde(rename = "AttributeName")]
pub attribute_name: String,
#[serde(rename = "Value")]
pub value: TypedAttributeValue,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchAddFacetToObject {
#[serde(rename = "ObjectAttributeList")]
pub object_attribute_list: Vec<AttributeKeyAndValue>,
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
#[serde(rename = "SchemaFacet")]
pub schema_facet: SchemaFacet,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchAddFacetToObjectResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchAttachObject {
#[serde(rename = "ChildReference")]
pub child_reference: ObjectReference,
#[serde(rename = "LinkName")]
pub link_name: String,
#[serde(rename = "ParentReference")]
pub parent_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchAttachObjectResponse {
#[serde(rename = "attachedObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attached_object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchAttachPolicy {
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
#[serde(rename = "PolicyReference")]
pub policy_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchAttachPolicyResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchAttachToIndex {
#[serde(rename = "IndexReference")]
pub index_reference: ObjectReference,
#[serde(rename = "TargetReference")]
pub target_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchAttachToIndexResponse {
#[serde(rename = "AttachedObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attached_object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchAttachTypedLink {
#[serde(rename = "Attributes")]
pub attributes: Vec<AttributeNameAndValue>,
#[serde(rename = "SourceObjectReference")]
pub source_object_reference: ObjectReference,
#[serde(rename = "TargetObjectReference")]
pub target_object_reference: ObjectReference,
#[serde(rename = "TypedLinkFacet")]
pub typed_link_facet: TypedLinkSchemaAndFacetName,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchAttachTypedLinkResponse {
#[serde(rename = "TypedLinkSpecifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub typed_link_specifier: Option<TypedLinkSpecifier>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchCreateIndex {
#[serde(rename = "BatchReferenceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_reference_name: Option<String>,
#[serde(rename = "IsUnique")]
pub is_unique: bool,
#[serde(rename = "LinkName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub link_name: Option<String>,
#[serde(rename = "OrderedIndexedAttributeList")]
pub ordered_indexed_attribute_list: Vec<AttributeKey>,
#[serde(rename = "ParentReference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_reference: Option<ObjectReference>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchCreateIndexResponse {
#[serde(rename = "ObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchCreateObject {
#[serde(rename = "BatchReferenceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_reference_name: Option<String>,
#[serde(rename = "LinkName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub link_name: Option<String>,
#[serde(rename = "ObjectAttributeList")]
pub object_attribute_list: Vec<AttributeKeyAndValue>,
#[serde(rename = "ParentReference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_reference: Option<ObjectReference>,
#[serde(rename = "SchemaFacet")]
pub schema_facet: Vec<SchemaFacet>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchCreateObjectResponse {
#[serde(rename = "ObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDeleteObject {
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDeleteObjectResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDetachFromIndex {
#[serde(rename = "IndexReference")]
pub index_reference: ObjectReference,
#[serde(rename = "TargetReference")]
pub target_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDetachFromIndexResponse {
#[serde(rename = "DetachedObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detached_object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDetachObject {
#[serde(rename = "BatchReferenceName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub batch_reference_name: Option<String>,
#[serde(rename = "LinkName")]
pub link_name: String,
#[serde(rename = "ParentReference")]
pub parent_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDetachObjectResponse {
#[serde(rename = "detachedObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detached_object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDetachPolicy {
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
#[serde(rename = "PolicyReference")]
pub policy_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDetachPolicyResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchDetachTypedLink {
#[serde(rename = "TypedLinkSpecifier")]
pub typed_link_specifier: TypedLinkSpecifier,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchDetachTypedLinkResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetLinkAttributes {
#[serde(rename = "AttributeNames")]
pub attribute_names: Vec<String>,
#[serde(rename = "TypedLinkSpecifier")]
pub typed_link_specifier: TypedLinkSpecifier,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetLinkAttributesResponse {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<AttributeKeyAndValue>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetObjectAttributes {
#[serde(rename = "AttributeNames")]
pub attribute_names: Vec<String>,
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
#[serde(rename = "SchemaFacet")]
pub schema_facet: SchemaFacet,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetObjectAttributesResponse {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<AttributeKeyAndValue>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchGetObjectInformation {
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchGetObjectInformationResponse {
#[serde(rename = "ObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifier: Option<String>,
#[serde(rename = "SchemaFacets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_facets: Option<Vec<SchemaFacet>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchListAttachedIndices {
#[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 = "TargetReference")]
pub target_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchListAttachedIndicesResponse {
#[serde(rename = "IndexAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_attachments: Option<Vec<IndexAttachment>>,
#[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 BatchListIncomingTypedLinks {
#[serde(rename = "FilterAttributeRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_attribute_ranges: Option<Vec<TypedLinkAttributeRange>>,
#[serde(rename = "FilterTypedLink")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_typed_link: Option<TypedLinkSchemaAndFacetName>,
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchListIncomingTypedLinksResponse {
#[serde(rename = "LinkSpecifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub link_specifiers: Option<Vec<TypedLinkSpecifier>>,
#[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 BatchListIndex {
#[serde(rename = "IndexReference")]
pub index_reference: ObjectReference,
#[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 = "RangesOnIndexedValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ranges_on_indexed_values: Option<Vec<ObjectAttributeRange>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchListIndexResponse {
#[serde(rename = "IndexAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_attachments: Option<Vec<IndexAttachment>>,
#[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 BatchListObjectAttributes {
#[serde(rename = "FacetFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub facet_filter: Option<SchemaFacet>,
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchListObjectAttributesResponse {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<AttributeKeyAndValue>>,
#[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 BatchListObjectChildren {
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchListObjectChildrenResponse {
#[serde(rename = "Children")]
#[serde(skip_serializing_if = "Option::is_none")]
pub children: Option<::std::collections::HashMap<String, 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 BatchListObjectParentPaths {
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchListObjectParentPathsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PathToObjectIdentifiersList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path_to_object_identifiers_list: Option<Vec<PathToObjectIdentifiers>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchListObjectParents {
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchListObjectParentsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ParentLinks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_links: Option<Vec<ObjectIdentifierAndLinkNameTuple>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchListObjectPolicies {
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchListObjectPoliciesResponse {
#[serde(rename = "AttachedPolicyIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attached_policy_ids: 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 BatchListOutgoingTypedLinks {
#[serde(rename = "FilterAttributeRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_attribute_ranges: Option<Vec<TypedLinkAttributeRange>>,
#[serde(rename = "FilterTypedLink")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_typed_link: Option<TypedLinkSchemaAndFacetName>,
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchListOutgoingTypedLinksResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "TypedLinkSpecifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub typed_link_specifiers: Option<Vec<TypedLinkSpecifier>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchListPolicyAttachments {
#[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 = "PolicyReference")]
pub policy_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchListPolicyAttachmentsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ObjectIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifiers: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchLookupPolicy {
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchLookupPolicyResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PolicyToPathList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy_to_path_list: Option<Vec<PolicyToPath>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchReadException {
#[serde(rename = "Message")]
#[serde(skip_serializing_if = "Option::is_none")]
pub message: Option<String>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchReadOperation {
#[serde(rename = "GetLinkAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub get_link_attributes: Option<BatchGetLinkAttributes>,
#[serde(rename = "GetObjectAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub get_object_attributes: Option<BatchGetObjectAttributes>,
#[serde(rename = "GetObjectInformation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub get_object_information: Option<BatchGetObjectInformation>,
#[serde(rename = "ListAttachedIndices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_attached_indices: Option<BatchListAttachedIndices>,
#[serde(rename = "ListIncomingTypedLinks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_incoming_typed_links: Option<BatchListIncomingTypedLinks>,
#[serde(rename = "ListIndex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_index: Option<BatchListIndex>,
#[serde(rename = "ListObjectAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_object_attributes: Option<BatchListObjectAttributes>,
#[serde(rename = "ListObjectChildren")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_object_children: Option<BatchListObjectChildren>,
#[serde(rename = "ListObjectParentPaths")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_object_parent_paths: Option<BatchListObjectParentPaths>,
#[serde(rename = "ListObjectParents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_object_parents: Option<BatchListObjectParents>,
#[serde(rename = "ListObjectPolicies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_object_policies: Option<BatchListObjectPolicies>,
#[serde(rename = "ListOutgoingTypedLinks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_outgoing_typed_links: Option<BatchListOutgoingTypedLinks>,
#[serde(rename = "ListPolicyAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_policy_attachments: Option<BatchListPolicyAttachments>,
#[serde(rename = "LookupPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lookup_policy: Option<BatchLookupPolicy>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchReadOperationResponse {
#[serde(rename = "ExceptionResponse")]
#[serde(skip_serializing_if = "Option::is_none")]
pub exception_response: Option<BatchReadException>,
#[serde(rename = "SuccessfulResponse")]
#[serde(skip_serializing_if = "Option::is_none")]
pub successful_response: Option<BatchReadSuccessfulResponse>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchReadRequest {
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "Operations")]
pub operations: Vec<BatchReadOperation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchReadResponse {
#[serde(rename = "Responses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub responses: Option<Vec<BatchReadOperationResponse>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchReadSuccessfulResponse {
#[serde(rename = "GetLinkAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub get_link_attributes: Option<BatchGetLinkAttributesResponse>,
#[serde(rename = "GetObjectAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub get_object_attributes: Option<BatchGetObjectAttributesResponse>,
#[serde(rename = "GetObjectInformation")]
#[serde(skip_serializing_if = "Option::is_none")]
pub get_object_information: Option<BatchGetObjectInformationResponse>,
#[serde(rename = "ListAttachedIndices")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_attached_indices: Option<BatchListAttachedIndicesResponse>,
#[serde(rename = "ListIncomingTypedLinks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_incoming_typed_links: Option<BatchListIncomingTypedLinksResponse>,
#[serde(rename = "ListIndex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_index: Option<BatchListIndexResponse>,
#[serde(rename = "ListObjectAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_object_attributes: Option<BatchListObjectAttributesResponse>,
#[serde(rename = "ListObjectChildren")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_object_children: Option<BatchListObjectChildrenResponse>,
#[serde(rename = "ListObjectParentPaths")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_object_parent_paths: Option<BatchListObjectParentPathsResponse>,
#[serde(rename = "ListObjectParents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_object_parents: Option<BatchListObjectParentsResponse>,
#[serde(rename = "ListObjectPolicies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_object_policies: Option<BatchListObjectPoliciesResponse>,
#[serde(rename = "ListOutgoingTypedLinks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_outgoing_typed_links: Option<BatchListOutgoingTypedLinksResponse>,
#[serde(rename = "ListPolicyAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub list_policy_attachments: Option<BatchListPolicyAttachmentsResponse>,
#[serde(rename = "LookupPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub lookup_policy: Option<BatchLookupPolicyResponse>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchRemoveFacetFromObject {
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
#[serde(rename = "SchemaFacet")]
pub schema_facet: SchemaFacet,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchRemoveFacetFromObjectResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchUpdateLinkAttributes {
#[serde(rename = "AttributeUpdates")]
pub attribute_updates: Vec<LinkAttributeUpdate>,
#[serde(rename = "TypedLinkSpecifier")]
pub typed_link_specifier: TypedLinkSpecifier,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchUpdateLinkAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchUpdateObjectAttributes {
#[serde(rename = "AttributeUpdates")]
pub attribute_updates: Vec<ObjectAttributeUpdate>,
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchUpdateObjectAttributesResponse {
#[serde(rename = "ObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchWriteOperation {
#[serde(rename = "AddFacetToObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_facet_to_object: Option<BatchAddFacetToObject>,
#[serde(rename = "AttachObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attach_object: Option<BatchAttachObject>,
#[serde(rename = "AttachPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attach_policy: Option<BatchAttachPolicy>,
#[serde(rename = "AttachToIndex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attach_to_index: Option<BatchAttachToIndex>,
#[serde(rename = "AttachTypedLink")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attach_typed_link: Option<BatchAttachTypedLink>,
#[serde(rename = "CreateIndex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_index: Option<BatchCreateIndex>,
#[serde(rename = "CreateObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_object: Option<BatchCreateObject>,
#[serde(rename = "DeleteObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_object: Option<BatchDeleteObject>,
#[serde(rename = "DetachFromIndex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detach_from_index: Option<BatchDetachFromIndex>,
#[serde(rename = "DetachObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detach_object: Option<BatchDetachObject>,
#[serde(rename = "DetachPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detach_policy: Option<BatchDetachPolicy>,
#[serde(rename = "DetachTypedLink")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detach_typed_link: Option<BatchDetachTypedLink>,
#[serde(rename = "RemoveFacetFromObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_facet_from_object: Option<BatchRemoveFacetFromObject>,
#[serde(rename = "UpdateLinkAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_link_attributes: Option<BatchUpdateLinkAttributes>,
#[serde(rename = "UpdateObjectAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_object_attributes: Option<BatchUpdateObjectAttributes>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchWriteOperationResponse {
#[serde(rename = "AddFacetToObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub add_facet_to_object: Option<BatchAddFacetToObjectResponse>,
#[serde(rename = "AttachObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attach_object: Option<BatchAttachObjectResponse>,
#[serde(rename = "AttachPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attach_policy: Option<BatchAttachPolicyResponse>,
#[serde(rename = "AttachToIndex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attach_to_index: Option<BatchAttachToIndexResponse>,
#[serde(rename = "AttachTypedLink")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attach_typed_link: Option<BatchAttachTypedLinkResponse>,
#[serde(rename = "CreateIndex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_index: Option<BatchCreateIndexResponse>,
#[serde(rename = "CreateObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub create_object: Option<BatchCreateObjectResponse>,
#[serde(rename = "DeleteObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub delete_object: Option<BatchDeleteObjectResponse>,
#[serde(rename = "DetachFromIndex")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detach_from_index: Option<BatchDetachFromIndexResponse>,
#[serde(rename = "DetachObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detach_object: Option<BatchDetachObjectResponse>,
#[serde(rename = "DetachPolicy")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detach_policy: Option<BatchDetachPolicyResponse>,
#[serde(rename = "DetachTypedLink")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detach_typed_link: Option<BatchDetachTypedLinkResponse>,
#[serde(rename = "RemoveFacetFromObject")]
#[serde(skip_serializing_if = "Option::is_none")]
pub remove_facet_from_object: Option<BatchRemoveFacetFromObjectResponse>,
#[serde(rename = "UpdateLinkAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_link_attributes: Option<BatchUpdateLinkAttributesResponse>,
#[serde(rename = "UpdateObjectAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub update_object_attributes: Option<BatchUpdateObjectAttributesResponse>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct BatchWriteRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "Operations")]
pub operations: Vec<BatchWriteOperation>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct BatchWriteResponse {
#[serde(rename = "Responses")]
#[serde(skip_serializing_if = "Option::is_none")]
pub responses: Option<Vec<BatchWriteOperationResponse>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateDirectoryRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateDirectoryResponse {
#[serde(rename = "AppliedSchemaArn")]
pub applied_schema_arn: String,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "ObjectIdentifier")]
pub object_identifier: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateFacetRequest {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<FacetAttribute>>,
#[serde(rename = "FacetStyle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub facet_style: Option<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "ObjectType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_type: Option<String>,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateFacetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateIndexRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "IsUnique")]
pub is_unique: bool,
#[serde(rename = "LinkName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub link_name: Option<String>,
#[serde(rename = "OrderedIndexedAttributeList")]
pub ordered_indexed_attribute_list: Vec<AttributeKey>,
#[serde(rename = "ParentReference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_reference: Option<ObjectReference>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateIndexResponse {
#[serde(rename = "ObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateObjectRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "LinkName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub link_name: Option<String>,
#[serde(rename = "ObjectAttributeList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_attribute_list: Option<Vec<AttributeKeyAndValue>>,
#[serde(rename = "ParentReference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_reference: Option<ObjectReference>,
#[serde(rename = "SchemaFacets")]
pub schema_facets: Vec<SchemaFacet>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateObjectResponse {
#[serde(rename = "ObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateSchemaRequest {
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateSchemaResponse {
#[serde(rename = "SchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct CreateTypedLinkFacetRequest {
#[serde(rename = "Facet")]
pub facet: TypedLinkFacet,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct CreateTypedLinkFacetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteDirectoryRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteDirectoryResponse {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteFacetRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteFacetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteObjectRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteObjectResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteSchemaRequest {
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteSchemaResponse {
#[serde(rename = "SchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DeleteTypedLinkFacetRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DeleteTypedLinkFacetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetachFromIndexRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "IndexReference")]
pub index_reference: ObjectReference,
#[serde(rename = "TargetReference")]
pub target_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetachFromIndexResponse {
#[serde(rename = "DetachedObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detached_object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetachObjectRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "LinkName")]
pub link_name: String,
#[serde(rename = "ParentReference")]
pub parent_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetachObjectResponse {
#[serde(rename = "DetachedObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub detached_object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetachPolicyRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
#[serde(rename = "PolicyReference")]
pub policy_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DetachPolicyResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DetachTypedLinkRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "TypedLinkSpecifier")]
pub typed_link_specifier: TypedLinkSpecifier,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Directory {
#[serde(rename = "CreationDateTime")]
#[serde(skip_serializing_if = "Option::is_none")]
pub creation_date_time: Option<f64>,
#[serde(rename = "DirectoryArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_arn: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "State")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct DisableDirectoryRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct DisableDirectoryResponse {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct EnableDirectoryRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct EnableDirectoryResponse {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct Facet {
#[serde(rename = "FacetStyle")]
#[serde(skip_serializing_if = "Option::is_none")]
pub facet_style: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "ObjectType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FacetAttribute {
#[serde(rename = "AttributeDefinition")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_definition: Option<FacetAttributeDefinition>,
#[serde(rename = "AttributeReference")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_reference: Option<FacetAttributeReference>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RequiredBehavior")]
#[serde(skip_serializing_if = "Option::is_none")]
pub required_behavior: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FacetAttributeDefinition {
#[serde(rename = "DefaultValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_value: Option<TypedAttributeValue>,
#[serde(rename = "IsImmutable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_immutable: Option<bool>,
#[serde(rename = "Rules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rules: Option<::std::collections::HashMap<String, Rule>>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct FacetAttributeReference {
#[serde(rename = "TargetAttributeName")]
pub target_attribute_name: String,
#[serde(rename = "TargetFacetName")]
pub target_facet_name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct FacetAttributeUpdate {
#[serde(rename = "Action")]
#[serde(skip_serializing_if = "Option::is_none")]
pub action: Option<String>,
#[serde(rename = "Attribute")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute: Option<FacetAttribute>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetAppliedSchemaVersionRequest {
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetAppliedSchemaVersionResponse {
#[serde(rename = "AppliedSchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub applied_schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetDirectoryRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetDirectoryResponse {
#[serde(rename = "Directory")]
pub directory: Directory,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetFacetRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetFacetResponse {
#[serde(rename = "Facet")]
#[serde(skip_serializing_if = "Option::is_none")]
pub facet: Option<Facet>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetLinkAttributesRequest {
#[serde(rename = "AttributeNames")]
pub attribute_names: Vec<String>,
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "TypedLinkSpecifier")]
pub typed_link_specifier: TypedLinkSpecifier,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetLinkAttributesResponse {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<AttributeKeyAndValue>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetObjectAttributesRequest {
#[serde(rename = "AttributeNames")]
pub attribute_names: Vec<String>,
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
#[serde(rename = "SchemaFacet")]
pub schema_facet: SchemaFacet,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetObjectAttributesResponse {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<AttributeKeyAndValue>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetObjectInformationRequest {
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetObjectInformationResponse {
#[serde(rename = "ObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifier: Option<String>,
#[serde(rename = "SchemaFacets")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_facets: Option<Vec<SchemaFacet>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetSchemaAsJsonRequest {
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetSchemaAsJsonResponse {
#[serde(rename = "Document")]
#[serde(skip_serializing_if = "Option::is_none")]
pub document: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct GetTypedLinkFacetInformationRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct GetTypedLinkFacetInformationResponse {
#[serde(rename = "IdentityAttributeOrder")]
#[serde(skip_serializing_if = "Option::is_none")]
pub identity_attribute_order: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct IndexAttachment {
#[serde(rename = "IndexedAttributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub indexed_attributes: Option<Vec<AttributeKeyAndValue>>,
#[serde(rename = "ObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LinkAttributeAction {
#[serde(rename = "AttributeActionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_action_type: Option<String>,
#[serde(rename = "AttributeUpdateValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_update_value: Option<TypedAttributeValue>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct LinkAttributeUpdate {
#[serde(rename = "AttributeAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_action: Option<LinkAttributeAction>,
#[serde(rename = "AttributeKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_key: Option<AttributeKey>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAppliedSchemaArnsRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: 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 = "SchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAppliedSchemaArnsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SchemaArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arns: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListAttachedIndicesRequest {
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: 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 = "TargetReference")]
pub target_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListAttachedIndicesResponse {
#[serde(rename = "IndexAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_attachments: Option<Vec<IndexAttachment>>,
#[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 ListDevelopmentSchemaArnsRequest {
#[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 ListDevelopmentSchemaArnsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SchemaArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arns: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListDirectoriesRequest {
#[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 = "state")]
#[serde(skip_serializing_if = "Option::is_none")]
pub state: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListDirectoriesResponse {
#[serde(rename = "Directories")]
pub directories: Vec<Directory>,
#[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 ListFacetAttributesRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFacetAttributesResponse {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<FacetAttribute>>,
#[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 ListFacetNamesRequest {
#[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 = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListFacetNamesResponse {
#[serde(rename = "FacetNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub facet_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 ListIncomingTypedLinksRequest {
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "FilterAttributeRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_attribute_ranges: Option<Vec<TypedLinkAttributeRange>>,
#[serde(rename = "FilterTypedLink")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_typed_link: Option<TypedLinkSchemaAndFacetName>,
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListIncomingTypedLinksResponse {
#[serde(rename = "LinkSpecifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub link_specifiers: Option<Vec<TypedLinkSpecifier>>,
#[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 ListIndexRequest {
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "IndexReference")]
pub index_reference: ObjectReference,
#[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 = "RangesOnIndexedValues")]
#[serde(skip_serializing_if = "Option::is_none")]
pub ranges_on_indexed_values: Option<Vec<ObjectAttributeRange>>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListIndexResponse {
#[serde(rename = "IndexAttachments")]
#[serde(skip_serializing_if = "Option::is_none")]
pub index_attachments: Option<Vec<IndexAttachment>>,
#[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 ListManagedSchemaArnsRequest {
#[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 = "SchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListManagedSchemaArnsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SchemaArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arns: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListObjectAttributesRequest {
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "FacetFilter")]
#[serde(skip_serializing_if = "Option::is_none")]
pub facet_filter: Option<SchemaFacet>,
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListObjectAttributesResponse {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<AttributeKeyAndValue>>,
#[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 ListObjectChildrenRequest {
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: 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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListObjectChildrenResponse {
#[serde(rename = "Children")]
#[serde(skip_serializing_if = "Option::is_none")]
pub children: Option<::std::collections::HashMap<String, 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 ListObjectParentPathsRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: 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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListObjectParentPathsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PathToObjectIdentifiersList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path_to_object_identifiers_list: Option<Vec<PathToObjectIdentifiers>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListObjectParentsRequest {
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "IncludeAllLinksToEachParent")]
#[serde(skip_serializing_if = "Option::is_none")]
pub include_all_links_to_each_parent: Option<bool>,
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListObjectParentsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ParentLinks")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parent_links: Option<Vec<ObjectIdentifierAndLinkNameTuple>>,
#[serde(rename = "Parents")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parents: Option<::std::collections::HashMap<String, String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListObjectPoliciesRequest {
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: 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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListObjectPoliciesResponse {
#[serde(rename = "AttachedPolicyIds")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attached_policy_ids: 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 ListOutgoingTypedLinksRequest {
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "FilterAttributeRanges")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_attribute_ranges: Option<Vec<TypedLinkAttributeRange>>,
#[serde(rename = "FilterTypedLink")]
#[serde(skip_serializing_if = "Option::is_none")]
pub filter_typed_link: Option<TypedLinkSchemaAndFacetName>,
#[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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListOutgoingTypedLinksResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "TypedLinkSpecifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub typed_link_specifiers: Option<Vec<TypedLinkSpecifier>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPolicyAttachmentsRequest {
#[serde(rename = "ConsistencyLevel")]
#[serde(skip_serializing_if = "Option::is_none")]
pub consistency_level: Option<String>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: 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 = "PolicyReference")]
pub policy_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPolicyAttachmentsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "ObjectIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifiers: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListPublishedSchemaArnsRequest {
#[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 = "SchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListPublishedSchemaArnsResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SchemaArns")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arns: Option<Vec<String>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTagsForResourceRequest {
#[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 = "ResourceArn")]
pub resource_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTagsForResourceResponse {
#[serde(rename = "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<Vec<Tag>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ListTypedLinkFacetAttributesRequest {
#[serde(rename = "MaxResults")]
#[serde(skip_serializing_if = "Option::is_none")]
pub max_results: Option<i64>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTypedLinkFacetAttributesResponse {
#[serde(rename = "Attributes")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attributes: Option<Vec<TypedLinkAttributeDefinition>>,
#[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 ListTypedLinkFacetNamesRequest {
#[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 = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ListTypedLinkFacetNamesResponse {
#[serde(rename = "FacetNames")]
#[serde(skip_serializing_if = "Option::is_none")]
pub facet_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 LookupPolicyRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: 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 = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct LookupPolicyResponse {
#[serde(rename = "NextToken")]
#[serde(skip_serializing_if = "Option::is_none")]
pub next_token: Option<String>,
#[serde(rename = "PolicyToPathList")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy_to_path_list: Option<Vec<PolicyToPath>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ObjectAttributeAction {
#[serde(rename = "ObjectAttributeActionType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_attribute_action_type: Option<String>,
#[serde(rename = "ObjectAttributeUpdateValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_attribute_update_value: Option<TypedAttributeValue>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ObjectAttributeRange {
#[serde(rename = "AttributeKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_key: Option<AttributeKey>,
#[serde(rename = "Range")]
#[serde(skip_serializing_if = "Option::is_none")]
pub range: Option<TypedAttributeValueRange>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct ObjectAttributeUpdate {
#[serde(rename = "ObjectAttributeAction")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_attribute_action: Option<ObjectAttributeAction>,
#[serde(rename = "ObjectAttributeKey")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_attribute_key: Option<AttributeKey>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct ObjectIdentifierAndLinkNameTuple {
#[serde(rename = "LinkName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub link_name: Option<String>,
#[serde(rename = "ObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct ObjectReference {
#[serde(rename = "Selector")]
#[serde(skip_serializing_if = "Option::is_none")]
pub selector: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PathToObjectIdentifiers {
#[serde(rename = "ObjectIdentifiers")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifiers: Option<Vec<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 PolicyAttachment {
#[serde(rename = "ObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifier: Option<String>,
#[serde(rename = "PolicyId")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy_id: Option<String>,
#[serde(rename = "PolicyType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policy_type: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PolicyToPath {
#[serde(rename = "Path")]
#[serde(skip_serializing_if = "Option::is_none")]
pub path: Option<String>,
#[serde(rename = "Policies")]
#[serde(skip_serializing_if = "Option::is_none")]
pub policies: Option<Vec<PolicyAttachment>>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PublishSchemaRequest {
#[serde(rename = "DevelopmentSchemaArn")]
pub development_schema_arn: String,
#[serde(rename = "MinorVersion")]
#[serde(skip_serializing_if = "Option::is_none")]
pub minor_version: Option<String>,
#[serde(rename = "Name")]
#[serde(skip_serializing_if = "Option::is_none")]
pub name: Option<String>,
#[serde(rename = "Version")]
pub version: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PublishSchemaResponse {
#[serde(rename = "PublishedSchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub published_schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct PutSchemaFromJsonRequest {
#[serde(rename = "Document")]
pub document: String,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct PutSchemaFromJsonResponse {
#[serde(rename = "Arn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct RemoveFacetFromObjectRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
#[serde(rename = "SchemaFacet")]
pub schema_facet: SchemaFacet,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct RemoveFacetFromObjectResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Rule {
#[serde(rename = "Parameters")]
#[serde(skip_serializing_if = "Option::is_none")]
pub parameters: Option<::std::collections::HashMap<String, String>>,
#[serde(rename = "Type")]
#[serde(skip_serializing_if = "Option::is_none")]
pub type_: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct SchemaFacet {
#[serde(rename = "FacetName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub facet_name: Option<String>,
#[serde(rename = "SchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct Tag {
#[serde(rename = "Key")]
#[serde(skip_serializing_if = "Option::is_none")]
pub key: Option<String>,
#[serde(rename = "Value")]
#[serde(skip_serializing_if = "Option::is_none")]
pub value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "Tags")]
pub tags: Vec<Tag>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct TagResourceResponse {}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TypedAttributeValue {
#[serde(rename = "BinaryValue")]
#[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 binary_value: Option<bytes::Bytes>,
#[serde(rename = "BooleanValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub boolean_value: Option<bool>,
#[serde(rename = "DatetimeValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub datetime_value: Option<f64>,
#[serde(rename = "NumberValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub number_value: Option<String>,
#[serde(rename = "StringValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub string_value: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TypedAttributeValueRange {
#[serde(rename = "EndMode")]
pub end_mode: String,
#[serde(rename = "EndValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub end_value: Option<TypedAttributeValue>,
#[serde(rename = "StartMode")]
pub start_mode: String,
#[serde(rename = "StartValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub start_value: Option<TypedAttributeValue>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TypedLinkAttributeDefinition {
#[serde(rename = "DefaultValue")]
#[serde(skip_serializing_if = "Option::is_none")]
pub default_value: Option<TypedAttributeValue>,
#[serde(rename = "IsImmutable")]
#[serde(skip_serializing_if = "Option::is_none")]
pub is_immutable: Option<bool>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "RequiredBehavior")]
pub required_behavior: String,
#[serde(rename = "Rules")]
#[serde(skip_serializing_if = "Option::is_none")]
pub rules: Option<::std::collections::HashMap<String, Rule>>,
#[serde(rename = "Type")]
pub type_: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TypedLinkAttributeRange {
#[serde(rename = "AttributeName")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_name: Option<String>,
#[serde(rename = "Range")]
pub range: TypedAttributeValueRange,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TypedLinkFacet {
#[serde(rename = "Attributes")]
pub attributes: Vec<TypedLinkAttributeDefinition>,
#[serde(rename = "IdentityAttributeOrder")]
pub identity_attribute_order: Vec<String>,
#[serde(rename = "Name")]
pub name: String,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct TypedLinkFacetAttributeUpdate {
#[serde(rename = "Action")]
pub action: String,
#[serde(rename = "Attribute")]
pub attribute: TypedLinkAttributeDefinition,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TypedLinkSchemaAndFacetName {
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
#[serde(rename = "TypedLinkName")]
pub typed_link_name: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq, Serialize)]
pub struct TypedLinkSpecifier {
#[serde(rename = "IdentityAttributeValues")]
pub identity_attribute_values: Vec<AttributeNameAndValue>,
#[serde(rename = "SourceObjectReference")]
pub source_object_reference: ObjectReference,
#[serde(rename = "TargetObjectReference")]
pub target_object_reference: ObjectReference,
#[serde(rename = "TypedLinkFacet")]
pub typed_link_facet: TypedLinkSchemaAndFacetName,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UntagResourceRequest {
#[serde(rename = "ResourceArn")]
pub resource_arn: String,
#[serde(rename = "TagKeys")]
pub tag_keys: Vec<String>,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UntagResourceResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateFacetRequest {
#[serde(rename = "AttributeUpdates")]
#[serde(skip_serializing_if = "Option::is_none")]
pub attribute_updates: Option<Vec<FacetAttributeUpdate>>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "ObjectType")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_type: Option<String>,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateFacetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateLinkAttributesRequest {
#[serde(rename = "AttributeUpdates")]
pub attribute_updates: Vec<LinkAttributeUpdate>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "TypedLinkSpecifier")]
pub typed_link_specifier: TypedLinkSpecifier,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateLinkAttributesResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateObjectAttributesRequest {
#[serde(rename = "AttributeUpdates")]
pub attribute_updates: Vec<ObjectAttributeUpdate>,
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "ObjectReference")]
pub object_reference: ObjectReference,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateObjectAttributesResponse {
#[serde(rename = "ObjectIdentifier")]
#[serde(skip_serializing_if = "Option::is_none")]
pub object_identifier: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateSchemaRequest {
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateSchemaResponse {
#[serde(rename = "SchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpdateTypedLinkFacetRequest {
#[serde(rename = "AttributeUpdates")]
pub attribute_updates: Vec<TypedLinkFacetAttributeUpdate>,
#[serde(rename = "IdentityAttributeOrder")]
pub identity_attribute_order: Vec<String>,
#[serde(rename = "Name")]
pub name: String,
#[serde(rename = "SchemaArn")]
pub schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpdateTypedLinkFacetResponse {}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpgradeAppliedSchemaRequest {
#[serde(rename = "DirectoryArn")]
pub directory_arn: String,
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "PublishedSchemaArn")]
pub published_schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpgradeAppliedSchemaResponse {
#[serde(rename = "DirectoryArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub directory_arn: Option<String>,
#[serde(rename = "UpgradedSchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upgraded_schema_arn: Option<String>,
}
#[derive(Clone, Debug, Default, PartialEq, Serialize)]
#[cfg_attr(feature = "deserialize_structs", derive(Deserialize))]
pub struct UpgradePublishedSchemaRequest {
#[serde(rename = "DevelopmentSchemaArn")]
pub development_schema_arn: String,
#[serde(rename = "DryRun")]
#[serde(skip_serializing_if = "Option::is_none")]
pub dry_run: Option<bool>,
#[serde(rename = "MinorVersion")]
pub minor_version: String,
#[serde(rename = "PublishedSchemaArn")]
pub published_schema_arn: String,
}
#[derive(Clone, Debug, Default, Deserialize, PartialEq)]
#[cfg_attr(any(test, feature = "serialize_structs"), derive(Serialize))]
pub struct UpgradePublishedSchemaResponse {
#[serde(rename = "UpgradedSchemaArn")]
#[serde(skip_serializing_if = "Option::is_none")]
pub upgraded_schema_arn: Option<String>,
}
#[derive(Debug, PartialEq)]
pub enum AddFacetToObjectError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl AddFacetToObjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AddFacetToObjectError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AddFacetToObjectError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(AddFacetToObjectError::DirectoryNotEnabled(
err.msg,
))
}
"FacetValidationException" => {
return RusotoError::Service(AddFacetToObjectError::FacetValidation(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(AddFacetToObjectError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(AddFacetToObjectError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(AddFacetToObjectError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AddFacetToObjectError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(AddFacetToObjectError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AddFacetToObjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AddFacetToObjectError::AccessDenied(ref cause) => write!(f, "{}", cause),
AddFacetToObjectError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
AddFacetToObjectError::FacetValidation(ref cause) => write!(f, "{}", cause),
AddFacetToObjectError::InternalService(ref cause) => write!(f, "{}", cause),
AddFacetToObjectError::InvalidArn(ref cause) => write!(f, "{}", cause),
AddFacetToObjectError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AddFacetToObjectError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AddFacetToObjectError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AddFacetToObjectError {}
#[derive(Debug, PartialEq)]
pub enum ApplySchemaError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidAttachment(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
SchemaAlreadyExists(String),
}
impl ApplySchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ApplySchemaError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ApplySchemaError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(ApplySchemaError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(ApplySchemaError::InvalidArn(err.msg))
}
"InvalidAttachmentException" => {
return RusotoError::Service(ApplySchemaError::InvalidAttachment(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ApplySchemaError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ApplySchemaError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(ApplySchemaError::RetryableConflict(err.msg))
}
"SchemaAlreadyExistsException" => {
return RusotoError::Service(ApplySchemaError::SchemaAlreadyExists(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ApplySchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ApplySchemaError::AccessDenied(ref cause) => write!(f, "{}", cause),
ApplySchemaError::InternalService(ref cause) => write!(f, "{}", cause),
ApplySchemaError::InvalidArn(ref cause) => write!(f, "{}", cause),
ApplySchemaError::InvalidAttachment(ref cause) => write!(f, "{}", cause),
ApplySchemaError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ApplySchemaError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ApplySchemaError::RetryableConflict(ref cause) => write!(f, "{}", cause),
ApplySchemaError::SchemaAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ApplySchemaError {}
#[derive(Debug, PartialEq)]
pub enum AttachObjectError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
InvalidAttachment(String),
LimitExceeded(String),
LinkNameAlreadyInUse(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl AttachObjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachObjectError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AttachObjectError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(AttachObjectError::DirectoryNotEnabled(err.msg))
}
"FacetValidationException" => {
return RusotoError::Service(AttachObjectError::FacetValidation(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(AttachObjectError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(AttachObjectError::InvalidArn(err.msg))
}
"InvalidAttachmentException" => {
return RusotoError::Service(AttachObjectError::InvalidAttachment(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(AttachObjectError::LimitExceeded(err.msg))
}
"LinkNameAlreadyInUseException" => {
return RusotoError::Service(AttachObjectError::LinkNameAlreadyInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AttachObjectError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(AttachObjectError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AttachObjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AttachObjectError::AccessDenied(ref cause) => write!(f, "{}", cause),
AttachObjectError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
AttachObjectError::FacetValidation(ref cause) => write!(f, "{}", cause),
AttachObjectError::InternalService(ref cause) => write!(f, "{}", cause),
AttachObjectError::InvalidArn(ref cause) => write!(f, "{}", cause),
AttachObjectError::InvalidAttachment(ref cause) => write!(f, "{}", cause),
AttachObjectError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AttachObjectError::LinkNameAlreadyInUse(ref cause) => write!(f, "{}", cause),
AttachObjectError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AttachObjectError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AttachObjectError {}
#[derive(Debug, PartialEq)]
pub enum AttachPolicyError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
NotPolicy(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl AttachPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AttachPolicyError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(AttachPolicyError::DirectoryNotEnabled(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(AttachPolicyError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(AttachPolicyError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(AttachPolicyError::LimitExceeded(err.msg))
}
"NotPolicyException" => {
return RusotoError::Service(AttachPolicyError::NotPolicy(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AttachPolicyError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(AttachPolicyError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AttachPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AttachPolicyError::AccessDenied(ref cause) => write!(f, "{}", cause),
AttachPolicyError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
AttachPolicyError::InternalService(ref cause) => write!(f, "{}", cause),
AttachPolicyError::InvalidArn(ref cause) => write!(f, "{}", cause),
AttachPolicyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AttachPolicyError::NotPolicy(ref cause) => write!(f, "{}", cause),
AttachPolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AttachPolicyError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AttachPolicyError {}
#[derive(Debug, PartialEq)]
pub enum AttachToIndexError {
AccessDenied(String),
DirectoryNotEnabled(String),
IndexedAttributeMissing(String),
InternalService(String),
InvalidArn(String),
InvalidAttachment(String),
LimitExceeded(String),
LinkNameAlreadyInUse(String),
NotIndex(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl AttachToIndexError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachToIndexError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AttachToIndexError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(AttachToIndexError::DirectoryNotEnabled(err.msg))
}
"IndexedAttributeMissingException" => {
return RusotoError::Service(AttachToIndexError::IndexedAttributeMissing(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(AttachToIndexError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(AttachToIndexError::InvalidArn(err.msg))
}
"InvalidAttachmentException" => {
return RusotoError::Service(AttachToIndexError::InvalidAttachment(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(AttachToIndexError::LimitExceeded(err.msg))
}
"LinkNameAlreadyInUseException" => {
return RusotoError::Service(AttachToIndexError::LinkNameAlreadyInUse(err.msg))
}
"NotIndexException" => {
return RusotoError::Service(AttachToIndexError::NotIndex(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AttachToIndexError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(AttachToIndexError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AttachToIndexError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AttachToIndexError::AccessDenied(ref cause) => write!(f, "{}", cause),
AttachToIndexError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
AttachToIndexError::IndexedAttributeMissing(ref cause) => write!(f, "{}", cause),
AttachToIndexError::InternalService(ref cause) => write!(f, "{}", cause),
AttachToIndexError::InvalidArn(ref cause) => write!(f, "{}", cause),
AttachToIndexError::InvalidAttachment(ref cause) => write!(f, "{}", cause),
AttachToIndexError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AttachToIndexError::LinkNameAlreadyInUse(ref cause) => write!(f, "{}", cause),
AttachToIndexError::NotIndex(ref cause) => write!(f, "{}", cause),
AttachToIndexError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AttachToIndexError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AttachToIndexError {}
#[derive(Debug, PartialEq)]
pub enum AttachTypedLinkError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
InvalidAttachment(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl AttachTypedLinkError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<AttachTypedLinkError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(AttachTypedLinkError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(AttachTypedLinkError::DirectoryNotEnabled(err.msg))
}
"FacetValidationException" => {
return RusotoError::Service(AttachTypedLinkError::FacetValidation(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(AttachTypedLinkError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(AttachTypedLinkError::InvalidArn(err.msg))
}
"InvalidAttachmentException" => {
return RusotoError::Service(AttachTypedLinkError::InvalidAttachment(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(AttachTypedLinkError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(AttachTypedLinkError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(AttachTypedLinkError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for AttachTypedLinkError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
AttachTypedLinkError::AccessDenied(ref cause) => write!(f, "{}", cause),
AttachTypedLinkError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
AttachTypedLinkError::FacetValidation(ref cause) => write!(f, "{}", cause),
AttachTypedLinkError::InternalService(ref cause) => write!(f, "{}", cause),
AttachTypedLinkError::InvalidArn(ref cause) => write!(f, "{}", cause),
AttachTypedLinkError::InvalidAttachment(ref cause) => write!(f, "{}", cause),
AttachTypedLinkError::LimitExceeded(ref cause) => write!(f, "{}", cause),
AttachTypedLinkError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
AttachTypedLinkError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for AttachTypedLinkError {}
#[derive(Debug, PartialEq)]
pub enum BatchReadError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
RetryableConflict(String),
}
impl BatchReadError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchReadError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(BatchReadError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(BatchReadError::DirectoryNotEnabled(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(BatchReadError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(BatchReadError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(BatchReadError::LimitExceeded(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(BatchReadError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchReadError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchReadError::AccessDenied(ref cause) => write!(f, "{}", cause),
BatchReadError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
BatchReadError::InternalService(ref cause) => write!(f, "{}", cause),
BatchReadError::InvalidArn(ref cause) => write!(f, "{}", cause),
BatchReadError::LimitExceeded(ref cause) => write!(f, "{}", cause),
BatchReadError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchReadError {}
#[derive(Debug, PartialEq)]
pub enum BatchWriteError {
AccessDenied(String),
BatchWrite(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
RetryableConflict(String),
}
impl BatchWriteError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<BatchWriteError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(BatchWriteError::AccessDenied(err.msg))
}
"BatchWriteException" => {
return RusotoError::Service(BatchWriteError::BatchWrite(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(BatchWriteError::DirectoryNotEnabled(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(BatchWriteError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(BatchWriteError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(BatchWriteError::LimitExceeded(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(BatchWriteError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for BatchWriteError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
BatchWriteError::AccessDenied(ref cause) => write!(f, "{}", cause),
BatchWriteError::BatchWrite(ref cause) => write!(f, "{}", cause),
BatchWriteError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
BatchWriteError::InternalService(ref cause) => write!(f, "{}", cause),
BatchWriteError::InvalidArn(ref cause) => write!(f, "{}", cause),
BatchWriteError::LimitExceeded(ref cause) => write!(f, "{}", cause),
BatchWriteError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for BatchWriteError {}
#[derive(Debug, PartialEq)]
pub enum CreateDirectoryError {
AccessDenied(String),
DirectoryAlreadyExists(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl CreateDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateDirectoryError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateDirectoryError::AccessDenied(err.msg))
}
"DirectoryAlreadyExistsException" => {
return RusotoError::Service(CreateDirectoryError::DirectoryAlreadyExists(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(CreateDirectoryError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(CreateDirectoryError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateDirectoryError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateDirectoryError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(CreateDirectoryError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateDirectoryError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateDirectoryError::DirectoryAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateDirectoryError::InternalService(ref cause) => write!(f, "{}", cause),
CreateDirectoryError::InvalidArn(ref cause) => write!(f, "{}", cause),
CreateDirectoryError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateDirectoryError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateDirectoryError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum CreateFacetError {
AccessDenied(String),
FacetAlreadyExists(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
InvalidRule(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl CreateFacetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateFacetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateFacetError::AccessDenied(err.msg))
}
"FacetAlreadyExistsException" => {
return RusotoError::Service(CreateFacetError::FacetAlreadyExists(err.msg))
}
"FacetValidationException" => {
return RusotoError::Service(CreateFacetError::FacetValidation(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(CreateFacetError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(CreateFacetError::InvalidArn(err.msg))
}
"InvalidRuleException" => {
return RusotoError::Service(CreateFacetError::InvalidRule(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateFacetError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateFacetError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(CreateFacetError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateFacetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateFacetError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateFacetError::FacetAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateFacetError::FacetValidation(ref cause) => write!(f, "{}", cause),
CreateFacetError::InternalService(ref cause) => write!(f, "{}", cause),
CreateFacetError::InvalidArn(ref cause) => write!(f, "{}", cause),
CreateFacetError::InvalidRule(ref cause) => write!(f, "{}", cause),
CreateFacetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateFacetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateFacetError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateFacetError {}
#[derive(Debug, PartialEq)]
pub enum CreateIndexError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
LinkNameAlreadyInUse(String),
ResourceNotFound(String),
RetryableConflict(String),
UnsupportedIndexType(String),
}
impl CreateIndexError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateIndexError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateIndexError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(CreateIndexError::DirectoryNotEnabled(err.msg))
}
"FacetValidationException" => {
return RusotoError::Service(CreateIndexError::FacetValidation(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(CreateIndexError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(CreateIndexError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateIndexError::LimitExceeded(err.msg))
}
"LinkNameAlreadyInUseException" => {
return RusotoError::Service(CreateIndexError::LinkNameAlreadyInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateIndexError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(CreateIndexError::RetryableConflict(err.msg))
}
"UnsupportedIndexTypeException" => {
return RusotoError::Service(CreateIndexError::UnsupportedIndexType(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateIndexError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateIndexError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateIndexError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
CreateIndexError::FacetValidation(ref cause) => write!(f, "{}", cause),
CreateIndexError::InternalService(ref cause) => write!(f, "{}", cause),
CreateIndexError::InvalidArn(ref cause) => write!(f, "{}", cause),
CreateIndexError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateIndexError::LinkNameAlreadyInUse(ref cause) => write!(f, "{}", cause),
CreateIndexError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateIndexError::RetryableConflict(ref cause) => write!(f, "{}", cause),
CreateIndexError::UnsupportedIndexType(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateIndexError {}
#[derive(Debug, PartialEq)]
pub enum CreateObjectError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
LinkNameAlreadyInUse(String),
ResourceNotFound(String),
RetryableConflict(String),
UnsupportedIndexType(String),
}
impl CreateObjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateObjectError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateObjectError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(CreateObjectError::DirectoryNotEnabled(err.msg))
}
"FacetValidationException" => {
return RusotoError::Service(CreateObjectError::FacetValidation(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(CreateObjectError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(CreateObjectError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateObjectError::LimitExceeded(err.msg))
}
"LinkNameAlreadyInUseException" => {
return RusotoError::Service(CreateObjectError::LinkNameAlreadyInUse(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateObjectError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(CreateObjectError::RetryableConflict(err.msg))
}
"UnsupportedIndexTypeException" => {
return RusotoError::Service(CreateObjectError::UnsupportedIndexType(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateObjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateObjectError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateObjectError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
CreateObjectError::FacetValidation(ref cause) => write!(f, "{}", cause),
CreateObjectError::InternalService(ref cause) => write!(f, "{}", cause),
CreateObjectError::InvalidArn(ref cause) => write!(f, "{}", cause),
CreateObjectError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateObjectError::LinkNameAlreadyInUse(ref cause) => write!(f, "{}", cause),
CreateObjectError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateObjectError::RetryableConflict(ref cause) => write!(f, "{}", cause),
CreateObjectError::UnsupportedIndexType(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateObjectError {}
#[derive(Debug, PartialEq)]
pub enum CreateSchemaError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
RetryableConflict(String),
SchemaAlreadyExists(String),
}
impl CreateSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateSchemaError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateSchemaError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(CreateSchemaError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(CreateSchemaError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateSchemaError::LimitExceeded(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(CreateSchemaError::RetryableConflict(err.msg))
}
"SchemaAlreadyExistsException" => {
return RusotoError::Service(CreateSchemaError::SchemaAlreadyExists(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateSchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateSchemaError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateSchemaError::InternalService(ref cause) => write!(f, "{}", cause),
CreateSchemaError::InvalidArn(ref cause) => write!(f, "{}", cause),
CreateSchemaError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateSchemaError::RetryableConflict(ref cause) => write!(f, "{}", cause),
CreateSchemaError::SchemaAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateSchemaError {}
#[derive(Debug, PartialEq)]
pub enum CreateTypedLinkFacetError {
AccessDenied(String),
FacetAlreadyExists(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
InvalidRule(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl CreateTypedLinkFacetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<CreateTypedLinkFacetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(CreateTypedLinkFacetError::AccessDenied(err.msg))
}
"FacetAlreadyExistsException" => {
return RusotoError::Service(CreateTypedLinkFacetError::FacetAlreadyExists(
err.msg,
))
}
"FacetValidationException" => {
return RusotoError::Service(CreateTypedLinkFacetError::FacetValidation(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(CreateTypedLinkFacetError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(CreateTypedLinkFacetError::InvalidArn(err.msg))
}
"InvalidRuleException" => {
return RusotoError::Service(CreateTypedLinkFacetError::InvalidRule(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(CreateTypedLinkFacetError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(CreateTypedLinkFacetError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(CreateTypedLinkFacetError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for CreateTypedLinkFacetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
CreateTypedLinkFacetError::AccessDenied(ref cause) => write!(f, "{}", cause),
CreateTypedLinkFacetError::FacetAlreadyExists(ref cause) => write!(f, "{}", cause),
CreateTypedLinkFacetError::FacetValidation(ref cause) => write!(f, "{}", cause),
CreateTypedLinkFacetError::InternalService(ref cause) => write!(f, "{}", cause),
CreateTypedLinkFacetError::InvalidArn(ref cause) => write!(f, "{}", cause),
CreateTypedLinkFacetError::InvalidRule(ref cause) => write!(f, "{}", cause),
CreateTypedLinkFacetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
CreateTypedLinkFacetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
CreateTypedLinkFacetError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for CreateTypedLinkFacetError {}
#[derive(Debug, PartialEq)]
pub enum DeleteDirectoryError {
AccessDenied(String),
DirectoryDeleted(String),
DirectoryNotDisabled(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl DeleteDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteDirectoryError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteDirectoryError::AccessDenied(err.msg))
}
"DirectoryDeletedException" => {
return RusotoError::Service(DeleteDirectoryError::DirectoryDeleted(err.msg))
}
"DirectoryNotDisabledException" => {
return RusotoError::Service(DeleteDirectoryError::DirectoryNotDisabled(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(DeleteDirectoryError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(DeleteDirectoryError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteDirectoryError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteDirectoryError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(DeleteDirectoryError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteDirectoryError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteDirectoryError::DirectoryDeleted(ref cause) => write!(f, "{}", cause),
DeleteDirectoryError::DirectoryNotDisabled(ref cause) => write!(f, "{}", cause),
DeleteDirectoryError::InternalService(ref cause) => write!(f, "{}", cause),
DeleteDirectoryError::InvalidArn(ref cause) => write!(f, "{}", cause),
DeleteDirectoryError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteDirectoryError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteDirectoryError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum DeleteFacetError {
AccessDenied(String),
FacetInUse(String),
FacetNotFound(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl DeleteFacetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteFacetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteFacetError::AccessDenied(err.msg))
}
"FacetInUseException" => {
return RusotoError::Service(DeleteFacetError::FacetInUse(err.msg))
}
"FacetNotFoundException" => {
return RusotoError::Service(DeleteFacetError::FacetNotFound(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DeleteFacetError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(DeleteFacetError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteFacetError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteFacetError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(DeleteFacetError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteFacetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteFacetError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteFacetError::FacetInUse(ref cause) => write!(f, "{}", cause),
DeleteFacetError::FacetNotFound(ref cause) => write!(f, "{}", cause),
DeleteFacetError::InternalService(ref cause) => write!(f, "{}", cause),
DeleteFacetError::InvalidArn(ref cause) => write!(f, "{}", cause),
DeleteFacetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteFacetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteFacetError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteFacetError {}
#[derive(Debug, PartialEq)]
pub enum DeleteObjectError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ObjectNotDetached(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl DeleteObjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteObjectError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteObjectError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(DeleteObjectError::DirectoryNotEnabled(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DeleteObjectError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(DeleteObjectError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteObjectError::LimitExceeded(err.msg))
}
"ObjectNotDetachedException" => {
return RusotoError::Service(DeleteObjectError::ObjectNotDetached(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteObjectError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(DeleteObjectError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteObjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteObjectError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteObjectError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
DeleteObjectError::InternalService(ref cause) => write!(f, "{}", cause),
DeleteObjectError::InvalidArn(ref cause) => write!(f, "{}", cause),
DeleteObjectError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteObjectError::ObjectNotDetached(ref cause) => write!(f, "{}", cause),
DeleteObjectError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteObjectError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteObjectError {}
#[derive(Debug, PartialEq)]
pub enum DeleteSchemaError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
StillContainsLinks(String),
}
impl DeleteSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteSchemaError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteSchemaError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DeleteSchemaError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(DeleteSchemaError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteSchemaError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteSchemaError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(DeleteSchemaError::RetryableConflict(err.msg))
}
"StillContainsLinksException" => {
return RusotoError::Service(DeleteSchemaError::StillContainsLinks(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteSchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteSchemaError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteSchemaError::InternalService(ref cause) => write!(f, "{}", cause),
DeleteSchemaError::InvalidArn(ref cause) => write!(f, "{}", cause),
DeleteSchemaError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteSchemaError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteSchemaError::RetryableConflict(ref cause) => write!(f, "{}", cause),
DeleteSchemaError::StillContainsLinks(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteSchemaError {}
#[derive(Debug, PartialEq)]
pub enum DeleteTypedLinkFacetError {
AccessDenied(String),
FacetNotFound(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl DeleteTypedLinkFacetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DeleteTypedLinkFacetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DeleteTypedLinkFacetError::AccessDenied(err.msg))
}
"FacetNotFoundException" => {
return RusotoError::Service(DeleteTypedLinkFacetError::FacetNotFound(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DeleteTypedLinkFacetError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(DeleteTypedLinkFacetError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DeleteTypedLinkFacetError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DeleteTypedLinkFacetError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(DeleteTypedLinkFacetError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DeleteTypedLinkFacetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DeleteTypedLinkFacetError::AccessDenied(ref cause) => write!(f, "{}", cause),
DeleteTypedLinkFacetError::FacetNotFound(ref cause) => write!(f, "{}", cause),
DeleteTypedLinkFacetError::InternalService(ref cause) => write!(f, "{}", cause),
DeleteTypedLinkFacetError::InvalidArn(ref cause) => write!(f, "{}", cause),
DeleteTypedLinkFacetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DeleteTypedLinkFacetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DeleteTypedLinkFacetError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DeleteTypedLinkFacetError {}
#[derive(Debug, PartialEq)]
pub enum DetachFromIndexError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
NotIndex(String),
ObjectAlreadyDetached(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl DetachFromIndexError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachFromIndexError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DetachFromIndexError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(DetachFromIndexError::DirectoryNotEnabled(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DetachFromIndexError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(DetachFromIndexError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DetachFromIndexError::LimitExceeded(err.msg))
}
"NotIndexException" => {
return RusotoError::Service(DetachFromIndexError::NotIndex(err.msg))
}
"ObjectAlreadyDetachedException" => {
return RusotoError::Service(DetachFromIndexError::ObjectAlreadyDetached(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DetachFromIndexError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(DetachFromIndexError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetachFromIndexError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetachFromIndexError::AccessDenied(ref cause) => write!(f, "{}", cause),
DetachFromIndexError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
DetachFromIndexError::InternalService(ref cause) => write!(f, "{}", cause),
DetachFromIndexError::InvalidArn(ref cause) => write!(f, "{}", cause),
DetachFromIndexError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DetachFromIndexError::NotIndex(ref cause) => write!(f, "{}", cause),
DetachFromIndexError::ObjectAlreadyDetached(ref cause) => write!(f, "{}", cause),
DetachFromIndexError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DetachFromIndexError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DetachFromIndexError {}
#[derive(Debug, PartialEq)]
pub enum DetachObjectError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
NotNode(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl DetachObjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachObjectError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DetachObjectError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(DetachObjectError::DirectoryNotEnabled(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DetachObjectError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(DetachObjectError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DetachObjectError::LimitExceeded(err.msg))
}
"NotNodeException" => {
return RusotoError::Service(DetachObjectError::NotNode(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DetachObjectError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(DetachObjectError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetachObjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetachObjectError::AccessDenied(ref cause) => write!(f, "{}", cause),
DetachObjectError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
DetachObjectError::InternalService(ref cause) => write!(f, "{}", cause),
DetachObjectError::InvalidArn(ref cause) => write!(f, "{}", cause),
DetachObjectError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DetachObjectError::NotNode(ref cause) => write!(f, "{}", cause),
DetachObjectError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DetachObjectError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DetachObjectError {}
#[derive(Debug, PartialEq)]
pub enum DetachPolicyError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
NotPolicy(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl DetachPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DetachPolicyError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(DetachPolicyError::DirectoryNotEnabled(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DetachPolicyError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(DetachPolicyError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DetachPolicyError::LimitExceeded(err.msg))
}
"NotPolicyException" => {
return RusotoError::Service(DetachPolicyError::NotPolicy(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DetachPolicyError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(DetachPolicyError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetachPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetachPolicyError::AccessDenied(ref cause) => write!(f, "{}", cause),
DetachPolicyError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
DetachPolicyError::InternalService(ref cause) => write!(f, "{}", cause),
DetachPolicyError::InvalidArn(ref cause) => write!(f, "{}", cause),
DetachPolicyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DetachPolicyError::NotPolicy(ref cause) => write!(f, "{}", cause),
DetachPolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DetachPolicyError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DetachPolicyError {}
#[derive(Debug, PartialEq)]
pub enum DetachTypedLinkError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl DetachTypedLinkError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DetachTypedLinkError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DetachTypedLinkError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(DetachTypedLinkError::DirectoryNotEnabled(err.msg))
}
"FacetValidationException" => {
return RusotoError::Service(DetachTypedLinkError::FacetValidation(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DetachTypedLinkError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(DetachTypedLinkError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DetachTypedLinkError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DetachTypedLinkError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(DetachTypedLinkError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DetachTypedLinkError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DetachTypedLinkError::AccessDenied(ref cause) => write!(f, "{}", cause),
DetachTypedLinkError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
DetachTypedLinkError::FacetValidation(ref cause) => write!(f, "{}", cause),
DetachTypedLinkError::InternalService(ref cause) => write!(f, "{}", cause),
DetachTypedLinkError::InvalidArn(ref cause) => write!(f, "{}", cause),
DetachTypedLinkError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DetachTypedLinkError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DetachTypedLinkError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DetachTypedLinkError {}
#[derive(Debug, PartialEq)]
pub enum DisableDirectoryError {
AccessDenied(String),
DirectoryDeleted(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl DisableDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<DisableDirectoryError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(DisableDirectoryError::AccessDenied(err.msg))
}
"DirectoryDeletedException" => {
return RusotoError::Service(DisableDirectoryError::DirectoryDeleted(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(DisableDirectoryError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(DisableDirectoryError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(DisableDirectoryError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(DisableDirectoryError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(DisableDirectoryError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for DisableDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
DisableDirectoryError::AccessDenied(ref cause) => write!(f, "{}", cause),
DisableDirectoryError::DirectoryDeleted(ref cause) => write!(f, "{}", cause),
DisableDirectoryError::InternalService(ref cause) => write!(f, "{}", cause),
DisableDirectoryError::InvalidArn(ref cause) => write!(f, "{}", cause),
DisableDirectoryError::LimitExceeded(ref cause) => write!(f, "{}", cause),
DisableDirectoryError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
DisableDirectoryError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for DisableDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum EnableDirectoryError {
AccessDenied(String),
DirectoryDeleted(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl EnableDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<EnableDirectoryError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(EnableDirectoryError::AccessDenied(err.msg))
}
"DirectoryDeletedException" => {
return RusotoError::Service(EnableDirectoryError::DirectoryDeleted(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(EnableDirectoryError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(EnableDirectoryError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(EnableDirectoryError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(EnableDirectoryError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(EnableDirectoryError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for EnableDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
EnableDirectoryError::AccessDenied(ref cause) => write!(f, "{}", cause),
EnableDirectoryError::DirectoryDeleted(ref cause) => write!(f, "{}", cause),
EnableDirectoryError::InternalService(ref cause) => write!(f, "{}", cause),
EnableDirectoryError::InvalidArn(ref cause) => write!(f, "{}", cause),
EnableDirectoryError::LimitExceeded(ref cause) => write!(f, "{}", cause),
EnableDirectoryError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
EnableDirectoryError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for EnableDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum GetAppliedSchemaVersionError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl GetAppliedSchemaVersionError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetAppliedSchemaVersionError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetAppliedSchemaVersionError::AccessDenied(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(GetAppliedSchemaVersionError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(GetAppliedSchemaVersionError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetAppliedSchemaVersionError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetAppliedSchemaVersionError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(GetAppliedSchemaVersionError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetAppliedSchemaVersionError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetAppliedSchemaVersionError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetAppliedSchemaVersionError::InternalService(ref cause) => write!(f, "{}", cause),
GetAppliedSchemaVersionError::InvalidArn(ref cause) => write!(f, "{}", cause),
GetAppliedSchemaVersionError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetAppliedSchemaVersionError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetAppliedSchemaVersionError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetAppliedSchemaVersionError {}
#[derive(Debug, PartialEq)]
pub enum GetDirectoryError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
RetryableConflict(String),
}
impl GetDirectoryError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetDirectoryError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetDirectoryError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(GetDirectoryError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(GetDirectoryError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetDirectoryError::LimitExceeded(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(GetDirectoryError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetDirectoryError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetDirectoryError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetDirectoryError::InternalService(ref cause) => write!(f, "{}", cause),
GetDirectoryError::InvalidArn(ref cause) => write!(f, "{}", cause),
GetDirectoryError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetDirectoryError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetDirectoryError {}
#[derive(Debug, PartialEq)]
pub enum GetFacetError {
AccessDenied(String),
FacetNotFound(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl GetFacetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetFacetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetFacetError::AccessDenied(err.msg))
}
"FacetNotFoundException" => {
return RusotoError::Service(GetFacetError::FacetNotFound(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(GetFacetError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(GetFacetError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetFacetError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetFacetError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(GetFacetError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetFacetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetFacetError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetFacetError::FacetNotFound(ref cause) => write!(f, "{}", cause),
GetFacetError::InternalService(ref cause) => write!(f, "{}", cause),
GetFacetError::InvalidArn(ref cause) => write!(f, "{}", cause),
GetFacetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetFacetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetFacetError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetFacetError {}
#[derive(Debug, PartialEq)]
pub enum GetLinkAttributesError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl GetLinkAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetLinkAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetLinkAttributesError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(GetLinkAttributesError::DirectoryNotEnabled(
err.msg,
))
}
"FacetValidationException" => {
return RusotoError::Service(GetLinkAttributesError::FacetValidation(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(GetLinkAttributesError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(GetLinkAttributesError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetLinkAttributesError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetLinkAttributesError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(GetLinkAttributesError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetLinkAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetLinkAttributesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetLinkAttributesError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
GetLinkAttributesError::FacetValidation(ref cause) => write!(f, "{}", cause),
GetLinkAttributesError::InternalService(ref cause) => write!(f, "{}", cause),
GetLinkAttributesError::InvalidArn(ref cause) => write!(f, "{}", cause),
GetLinkAttributesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetLinkAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetLinkAttributesError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetLinkAttributesError {}
#[derive(Debug, PartialEq)]
pub enum GetObjectAttributesError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl GetObjectAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetObjectAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetObjectAttributesError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(GetObjectAttributesError::DirectoryNotEnabled(
err.msg,
))
}
"FacetValidationException" => {
return RusotoError::Service(GetObjectAttributesError::FacetValidation(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(GetObjectAttributesError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(GetObjectAttributesError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetObjectAttributesError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetObjectAttributesError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(GetObjectAttributesError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetObjectAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetObjectAttributesError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetObjectAttributesError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
GetObjectAttributesError::FacetValidation(ref cause) => write!(f, "{}", cause),
GetObjectAttributesError::InternalService(ref cause) => write!(f, "{}", cause),
GetObjectAttributesError::InvalidArn(ref cause) => write!(f, "{}", cause),
GetObjectAttributesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetObjectAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetObjectAttributesError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetObjectAttributesError {}
#[derive(Debug, PartialEq)]
pub enum GetObjectInformationError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl GetObjectInformationError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetObjectInformationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetObjectInformationError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(GetObjectInformationError::DirectoryNotEnabled(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(GetObjectInformationError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(GetObjectInformationError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetObjectInformationError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetObjectInformationError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(GetObjectInformationError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetObjectInformationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetObjectInformationError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetObjectInformationError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
GetObjectInformationError::InternalService(ref cause) => write!(f, "{}", cause),
GetObjectInformationError::InvalidArn(ref cause) => write!(f, "{}", cause),
GetObjectInformationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetObjectInformationError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetObjectInformationError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetObjectInformationError {}
#[derive(Debug, PartialEq)]
pub enum GetSchemaAsJsonError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl GetSchemaAsJsonError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<GetSchemaAsJsonError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetSchemaAsJsonError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(GetSchemaAsJsonError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(GetSchemaAsJsonError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(GetSchemaAsJsonError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(GetSchemaAsJsonError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(GetSchemaAsJsonError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetSchemaAsJsonError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetSchemaAsJsonError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetSchemaAsJsonError::InternalService(ref cause) => write!(f, "{}", cause),
GetSchemaAsJsonError::InvalidArn(ref cause) => write!(f, "{}", cause),
GetSchemaAsJsonError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetSchemaAsJsonError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
GetSchemaAsJsonError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for GetSchemaAsJsonError {}
#[derive(Debug, PartialEq)]
pub enum GetTypedLinkFacetInformationError {
AccessDenied(String),
FacetNotFound(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl GetTypedLinkFacetInformationError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<GetTypedLinkFacetInformationError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(GetTypedLinkFacetInformationError::AccessDenied(
err.msg,
))
}
"FacetNotFoundException" => {
return RusotoError::Service(GetTypedLinkFacetInformationError::FacetNotFound(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(
GetTypedLinkFacetInformationError::InternalService(err.msg),
)
}
"InvalidArnException" => {
return RusotoError::Service(GetTypedLinkFacetInformationError::InvalidArn(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(
GetTypedLinkFacetInformationError::InvalidNextToken(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(GetTypedLinkFacetInformationError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
GetTypedLinkFacetInformationError::ResourceNotFound(err.msg),
)
}
"RetryableConflictException" => {
return RusotoError::Service(
GetTypedLinkFacetInformationError::RetryableConflict(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for GetTypedLinkFacetInformationError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
GetTypedLinkFacetInformationError::AccessDenied(ref cause) => write!(f, "{}", cause),
GetTypedLinkFacetInformationError::FacetNotFound(ref cause) => write!(f, "{}", cause),
GetTypedLinkFacetInformationError::InternalService(ref cause) => write!(f, "{}", cause),
GetTypedLinkFacetInformationError::InvalidArn(ref cause) => write!(f, "{}", cause),
GetTypedLinkFacetInformationError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
GetTypedLinkFacetInformationError::LimitExceeded(ref cause) => write!(f, "{}", cause),
GetTypedLinkFacetInformationError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
GetTypedLinkFacetInformationError::RetryableConflict(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for GetTypedLinkFacetInformationError {}
#[derive(Debug, PartialEq)]
pub enum ListAppliedSchemaArnsError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListAppliedSchemaArnsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAppliedSchemaArnsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListAppliedSchemaArnsError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(ListAppliedSchemaArnsError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(ListAppliedSchemaArnsError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListAppliedSchemaArnsError::InvalidNextToken(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListAppliedSchemaArnsError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListAppliedSchemaArnsError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListAppliedSchemaArnsError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAppliedSchemaArnsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAppliedSchemaArnsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListAppliedSchemaArnsError::InternalService(ref cause) => write!(f, "{}", cause),
ListAppliedSchemaArnsError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListAppliedSchemaArnsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListAppliedSchemaArnsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListAppliedSchemaArnsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListAppliedSchemaArnsError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListAppliedSchemaArnsError {}
#[derive(Debug, PartialEq)]
pub enum ListAttachedIndicesError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListAttachedIndicesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListAttachedIndicesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListAttachedIndicesError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(ListAttachedIndicesError::DirectoryNotEnabled(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListAttachedIndicesError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(ListAttachedIndicesError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListAttachedIndicesError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListAttachedIndicesError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListAttachedIndicesError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListAttachedIndicesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListAttachedIndicesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListAttachedIndicesError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
ListAttachedIndicesError::InternalService(ref cause) => write!(f, "{}", cause),
ListAttachedIndicesError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListAttachedIndicesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListAttachedIndicesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListAttachedIndicesError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListAttachedIndicesError {}
#[derive(Debug, PartialEq)]
pub enum ListDevelopmentSchemaArnsError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListDevelopmentSchemaArnsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDevelopmentSchemaArnsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListDevelopmentSchemaArnsError::AccessDenied(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListDevelopmentSchemaArnsError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(ListDevelopmentSchemaArnsError::InvalidArn(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListDevelopmentSchemaArnsError::InvalidNextToken(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListDevelopmentSchemaArnsError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListDevelopmentSchemaArnsError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListDevelopmentSchemaArnsError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDevelopmentSchemaArnsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDevelopmentSchemaArnsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListDevelopmentSchemaArnsError::InternalService(ref cause) => write!(f, "{}", cause),
ListDevelopmentSchemaArnsError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListDevelopmentSchemaArnsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListDevelopmentSchemaArnsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListDevelopmentSchemaArnsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListDevelopmentSchemaArnsError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDevelopmentSchemaArnsError {}
#[derive(Debug, PartialEq)]
pub enum ListDirectoriesError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
RetryableConflict(String),
}
impl ListDirectoriesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListDirectoriesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListDirectoriesError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(ListDirectoriesError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(ListDirectoriesError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListDirectoriesError::InvalidNextToken(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListDirectoriesError::LimitExceeded(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(ListDirectoriesError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListDirectoriesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListDirectoriesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListDirectoriesError::InternalService(ref cause) => write!(f, "{}", cause),
ListDirectoriesError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListDirectoriesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListDirectoriesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListDirectoriesError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListDirectoriesError {}
#[derive(Debug, PartialEq)]
pub enum ListFacetAttributesError {
AccessDenied(String),
FacetNotFound(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListFacetAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFacetAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListFacetAttributesError::AccessDenied(err.msg))
}
"FacetNotFoundException" => {
return RusotoError::Service(ListFacetAttributesError::FacetNotFound(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(ListFacetAttributesError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(ListFacetAttributesError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListFacetAttributesError::InvalidNextToken(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListFacetAttributesError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListFacetAttributesError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListFacetAttributesError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFacetAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFacetAttributesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListFacetAttributesError::FacetNotFound(ref cause) => write!(f, "{}", cause),
ListFacetAttributesError::InternalService(ref cause) => write!(f, "{}", cause),
ListFacetAttributesError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListFacetAttributesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListFacetAttributesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListFacetAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListFacetAttributesError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFacetAttributesError {}
#[derive(Debug, PartialEq)]
pub enum ListFacetNamesError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListFacetNamesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListFacetNamesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListFacetNamesError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(ListFacetNamesError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(ListFacetNamesError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListFacetNamesError::InvalidNextToken(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListFacetNamesError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListFacetNamesError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(ListFacetNamesError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListFacetNamesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListFacetNamesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListFacetNamesError::InternalService(ref cause) => write!(f, "{}", cause),
ListFacetNamesError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListFacetNamesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListFacetNamesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListFacetNamesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListFacetNamesError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListFacetNamesError {}
#[derive(Debug, PartialEq)]
pub enum ListIncomingTypedLinksError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListIncomingTypedLinksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListIncomingTypedLinksError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListIncomingTypedLinksError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(ListIncomingTypedLinksError::DirectoryNotEnabled(
err.msg,
))
}
"FacetValidationException" => {
return RusotoError::Service(ListIncomingTypedLinksError::FacetValidation(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListIncomingTypedLinksError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(ListIncomingTypedLinksError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListIncomingTypedLinksError::InvalidNextToken(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListIncomingTypedLinksError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListIncomingTypedLinksError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListIncomingTypedLinksError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListIncomingTypedLinksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListIncomingTypedLinksError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListIncomingTypedLinksError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
ListIncomingTypedLinksError::FacetValidation(ref cause) => write!(f, "{}", cause),
ListIncomingTypedLinksError::InternalService(ref cause) => write!(f, "{}", cause),
ListIncomingTypedLinksError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListIncomingTypedLinksError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListIncomingTypedLinksError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListIncomingTypedLinksError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListIncomingTypedLinksError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListIncomingTypedLinksError {}
#[derive(Debug, PartialEq)]
pub enum ListIndexError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
NotIndex(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListIndexError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListIndexError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListIndexError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(ListIndexError::DirectoryNotEnabled(err.msg))
}
"FacetValidationException" => {
return RusotoError::Service(ListIndexError::FacetValidation(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(ListIndexError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(ListIndexError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListIndexError::InvalidNextToken(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListIndexError::LimitExceeded(err.msg))
}
"NotIndexException" => {
return RusotoError::Service(ListIndexError::NotIndex(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListIndexError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(ListIndexError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListIndexError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListIndexError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListIndexError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
ListIndexError::FacetValidation(ref cause) => write!(f, "{}", cause),
ListIndexError::InternalService(ref cause) => write!(f, "{}", cause),
ListIndexError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListIndexError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListIndexError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListIndexError::NotIndex(ref cause) => write!(f, "{}", cause),
ListIndexError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListIndexError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListIndexError {}
#[derive(Debug, PartialEq)]
pub enum ListManagedSchemaArnsError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
ResourceNotFound(String),
}
impl ListManagedSchemaArnsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListManagedSchemaArnsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListManagedSchemaArnsError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(ListManagedSchemaArnsError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(ListManagedSchemaArnsError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListManagedSchemaArnsError::InvalidNextToken(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListManagedSchemaArnsError::ResourceNotFound(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListManagedSchemaArnsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListManagedSchemaArnsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListManagedSchemaArnsError::InternalService(ref cause) => write!(f, "{}", cause),
ListManagedSchemaArnsError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListManagedSchemaArnsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListManagedSchemaArnsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListManagedSchemaArnsError {}
#[derive(Debug, PartialEq)]
pub enum ListObjectAttributesError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListObjectAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListObjectAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListObjectAttributesError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(ListObjectAttributesError::DirectoryNotEnabled(
err.msg,
))
}
"FacetValidationException" => {
return RusotoError::Service(ListObjectAttributesError::FacetValidation(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListObjectAttributesError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(ListObjectAttributesError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListObjectAttributesError::InvalidNextToken(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListObjectAttributesError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListObjectAttributesError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListObjectAttributesError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListObjectAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListObjectAttributesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListObjectAttributesError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
ListObjectAttributesError::FacetValidation(ref cause) => write!(f, "{}", cause),
ListObjectAttributesError::InternalService(ref cause) => write!(f, "{}", cause),
ListObjectAttributesError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListObjectAttributesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListObjectAttributesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListObjectAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListObjectAttributesError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListObjectAttributesError {}
#[derive(Debug, PartialEq)]
pub enum ListObjectChildrenError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
NotNode(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListObjectChildrenError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListObjectChildrenError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListObjectChildrenError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(ListObjectChildrenError::DirectoryNotEnabled(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListObjectChildrenError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(ListObjectChildrenError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListObjectChildrenError::InvalidNextToken(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListObjectChildrenError::LimitExceeded(err.msg))
}
"NotNodeException" => {
return RusotoError::Service(ListObjectChildrenError::NotNode(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListObjectChildrenError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(ListObjectChildrenError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListObjectChildrenError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListObjectChildrenError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListObjectChildrenError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
ListObjectChildrenError::InternalService(ref cause) => write!(f, "{}", cause),
ListObjectChildrenError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListObjectChildrenError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListObjectChildrenError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListObjectChildrenError::NotNode(ref cause) => write!(f, "{}", cause),
ListObjectChildrenError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListObjectChildrenError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListObjectChildrenError {}
#[derive(Debug, PartialEq)]
pub enum ListObjectParentPathsError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListObjectParentPathsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListObjectParentPathsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListObjectParentPathsError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(ListObjectParentPathsError::DirectoryNotEnabled(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListObjectParentPathsError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(ListObjectParentPathsError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListObjectParentPathsError::InvalidNextToken(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListObjectParentPathsError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListObjectParentPathsError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListObjectParentPathsError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListObjectParentPathsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListObjectParentPathsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListObjectParentPathsError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
ListObjectParentPathsError::InternalService(ref cause) => write!(f, "{}", cause),
ListObjectParentPathsError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListObjectParentPathsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListObjectParentPathsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListObjectParentPathsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListObjectParentPathsError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListObjectParentPathsError {}
#[derive(Debug, PartialEq)]
pub enum ListObjectParentsError {
AccessDenied(String),
CannotListParentOfRoot(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListObjectParentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListObjectParentsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListObjectParentsError::AccessDenied(err.msg))
}
"CannotListParentOfRootException" => {
return RusotoError::Service(ListObjectParentsError::CannotListParentOfRoot(
err.msg,
))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(ListObjectParentsError::DirectoryNotEnabled(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListObjectParentsError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(ListObjectParentsError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListObjectParentsError::InvalidNextToken(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListObjectParentsError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListObjectParentsError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(ListObjectParentsError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListObjectParentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListObjectParentsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListObjectParentsError::CannotListParentOfRoot(ref cause) => write!(f, "{}", cause),
ListObjectParentsError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
ListObjectParentsError::InternalService(ref cause) => write!(f, "{}", cause),
ListObjectParentsError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListObjectParentsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListObjectParentsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListObjectParentsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListObjectParentsError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListObjectParentsError {}
#[derive(Debug, PartialEq)]
pub enum ListObjectPoliciesError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListObjectPoliciesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListObjectPoliciesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListObjectPoliciesError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(ListObjectPoliciesError::DirectoryNotEnabled(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListObjectPoliciesError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(ListObjectPoliciesError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListObjectPoliciesError::InvalidNextToken(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(ListObjectPoliciesError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListObjectPoliciesError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(ListObjectPoliciesError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListObjectPoliciesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListObjectPoliciesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListObjectPoliciesError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
ListObjectPoliciesError::InternalService(ref cause) => write!(f, "{}", cause),
ListObjectPoliciesError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListObjectPoliciesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListObjectPoliciesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListObjectPoliciesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListObjectPoliciesError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListObjectPoliciesError {}
#[derive(Debug, PartialEq)]
pub enum ListOutgoingTypedLinksError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListOutgoingTypedLinksError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListOutgoingTypedLinksError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListOutgoingTypedLinksError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(ListOutgoingTypedLinksError::DirectoryNotEnabled(
err.msg,
))
}
"FacetValidationException" => {
return RusotoError::Service(ListOutgoingTypedLinksError::FacetValidation(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListOutgoingTypedLinksError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(ListOutgoingTypedLinksError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListOutgoingTypedLinksError::InvalidNextToken(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListOutgoingTypedLinksError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListOutgoingTypedLinksError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListOutgoingTypedLinksError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListOutgoingTypedLinksError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListOutgoingTypedLinksError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListOutgoingTypedLinksError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
ListOutgoingTypedLinksError::FacetValidation(ref cause) => write!(f, "{}", cause),
ListOutgoingTypedLinksError::InternalService(ref cause) => write!(f, "{}", cause),
ListOutgoingTypedLinksError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListOutgoingTypedLinksError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListOutgoingTypedLinksError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListOutgoingTypedLinksError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListOutgoingTypedLinksError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListOutgoingTypedLinksError {}
#[derive(Debug, PartialEq)]
pub enum ListPolicyAttachmentsError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
NotPolicy(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListPolicyAttachmentsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPolicyAttachmentsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListPolicyAttachmentsError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(ListPolicyAttachmentsError::DirectoryNotEnabled(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListPolicyAttachmentsError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(ListPolicyAttachmentsError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListPolicyAttachmentsError::InvalidNextToken(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListPolicyAttachmentsError::LimitExceeded(err.msg))
}
"NotPolicyException" => {
return RusotoError::Service(ListPolicyAttachmentsError::NotPolicy(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListPolicyAttachmentsError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListPolicyAttachmentsError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPolicyAttachmentsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPolicyAttachmentsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListPolicyAttachmentsError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
ListPolicyAttachmentsError::InternalService(ref cause) => write!(f, "{}", cause),
ListPolicyAttachmentsError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListPolicyAttachmentsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListPolicyAttachmentsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListPolicyAttachmentsError::NotPolicy(ref cause) => write!(f, "{}", cause),
ListPolicyAttachmentsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListPolicyAttachmentsError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPolicyAttachmentsError {}
#[derive(Debug, PartialEq)]
pub enum ListPublishedSchemaArnsError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListPublishedSchemaArnsError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListPublishedSchemaArnsError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListPublishedSchemaArnsError::AccessDenied(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListPublishedSchemaArnsError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(ListPublishedSchemaArnsError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListPublishedSchemaArnsError::InvalidNextToken(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListPublishedSchemaArnsError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListPublishedSchemaArnsError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListPublishedSchemaArnsError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListPublishedSchemaArnsError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListPublishedSchemaArnsError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListPublishedSchemaArnsError::InternalService(ref cause) => write!(f, "{}", cause),
ListPublishedSchemaArnsError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListPublishedSchemaArnsError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListPublishedSchemaArnsError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListPublishedSchemaArnsError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListPublishedSchemaArnsError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListPublishedSchemaArnsError {}
#[derive(Debug, PartialEq)]
pub enum ListTagsForResourceError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidTaggingRequest(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListTagsForResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTagsForResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListTagsForResourceError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(ListTagsForResourceError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidArn(err.msg))
}
"InvalidTaggingRequestException" => {
return RusotoError::Service(ListTagsForResourceError::InvalidTaggingRequest(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListTagsForResourceError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTagsForResourceError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListTagsForResourceError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTagsForResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTagsForResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InternalService(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::InvalidTaggingRequest(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListTagsForResourceError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTagsForResourceError {}
#[derive(Debug, PartialEq)]
pub enum ListTypedLinkFacetAttributesError {
AccessDenied(String),
FacetNotFound(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListTypedLinkFacetAttributesError {
pub fn from_response(
res: BufferedHttpResponse,
) -> RusotoError<ListTypedLinkFacetAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListTypedLinkFacetAttributesError::AccessDenied(
err.msg,
))
}
"FacetNotFoundException" => {
return RusotoError::Service(ListTypedLinkFacetAttributesError::FacetNotFound(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(
ListTypedLinkFacetAttributesError::InternalService(err.msg),
)
}
"InvalidArnException" => {
return RusotoError::Service(ListTypedLinkFacetAttributesError::InvalidArn(
err.msg,
))
}
"InvalidNextTokenException" => {
return RusotoError::Service(
ListTypedLinkFacetAttributesError::InvalidNextToken(err.msg),
)
}
"LimitExceededException" => {
return RusotoError::Service(ListTypedLinkFacetAttributesError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(
ListTypedLinkFacetAttributesError::ResourceNotFound(err.msg),
)
}
"RetryableConflictException" => {
return RusotoError::Service(
ListTypedLinkFacetAttributesError::RetryableConflict(err.msg),
)
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTypedLinkFacetAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTypedLinkFacetAttributesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListTypedLinkFacetAttributesError::FacetNotFound(ref cause) => write!(f, "{}", cause),
ListTypedLinkFacetAttributesError::InternalService(ref cause) => write!(f, "{}", cause),
ListTypedLinkFacetAttributesError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListTypedLinkFacetAttributesError::InvalidNextToken(ref cause) => {
write!(f, "{}", cause)
}
ListTypedLinkFacetAttributesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListTypedLinkFacetAttributesError::ResourceNotFound(ref cause) => {
write!(f, "{}", cause)
}
ListTypedLinkFacetAttributesError::RetryableConflict(ref cause) => {
write!(f, "{}", cause)
}
}
}
}
impl Error for ListTypedLinkFacetAttributesError {}
#[derive(Debug, PartialEq)]
pub enum ListTypedLinkFacetNamesError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl ListTypedLinkFacetNamesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<ListTypedLinkFacetNamesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(ListTypedLinkFacetNamesError::AccessDenied(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(ListTypedLinkFacetNamesError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(ListTypedLinkFacetNamesError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(ListTypedLinkFacetNamesError::InvalidNextToken(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(ListTypedLinkFacetNamesError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(ListTypedLinkFacetNamesError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(ListTypedLinkFacetNamesError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for ListTypedLinkFacetNamesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
ListTypedLinkFacetNamesError::AccessDenied(ref cause) => write!(f, "{}", cause),
ListTypedLinkFacetNamesError::InternalService(ref cause) => write!(f, "{}", cause),
ListTypedLinkFacetNamesError::InvalidArn(ref cause) => write!(f, "{}", cause),
ListTypedLinkFacetNamesError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
ListTypedLinkFacetNamesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
ListTypedLinkFacetNamesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
ListTypedLinkFacetNamesError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for ListTypedLinkFacetNamesError {}
#[derive(Debug, PartialEq)]
pub enum LookupPolicyError {
AccessDenied(String),
DirectoryNotEnabled(String),
InternalService(String),
InvalidArn(String),
InvalidNextToken(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl LookupPolicyError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<LookupPolicyError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(LookupPolicyError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(LookupPolicyError::DirectoryNotEnabled(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(LookupPolicyError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(LookupPolicyError::InvalidArn(err.msg))
}
"InvalidNextTokenException" => {
return RusotoError::Service(LookupPolicyError::InvalidNextToken(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(LookupPolicyError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(LookupPolicyError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(LookupPolicyError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for LookupPolicyError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
LookupPolicyError::AccessDenied(ref cause) => write!(f, "{}", cause),
LookupPolicyError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
LookupPolicyError::InternalService(ref cause) => write!(f, "{}", cause),
LookupPolicyError::InvalidArn(ref cause) => write!(f, "{}", cause),
LookupPolicyError::InvalidNextToken(ref cause) => write!(f, "{}", cause),
LookupPolicyError::LimitExceeded(ref cause) => write!(f, "{}", cause),
LookupPolicyError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
LookupPolicyError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for LookupPolicyError {}
#[derive(Debug, PartialEq)]
pub enum PublishSchemaError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
SchemaAlreadyPublished(String),
}
impl PublishSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PublishSchemaError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(PublishSchemaError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(PublishSchemaError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(PublishSchemaError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(PublishSchemaError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(PublishSchemaError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(PublishSchemaError::RetryableConflict(err.msg))
}
"SchemaAlreadyPublishedException" => {
return RusotoError::Service(PublishSchemaError::SchemaAlreadyPublished(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PublishSchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PublishSchemaError::AccessDenied(ref cause) => write!(f, "{}", cause),
PublishSchemaError::InternalService(ref cause) => write!(f, "{}", cause),
PublishSchemaError::InvalidArn(ref cause) => write!(f, "{}", cause),
PublishSchemaError::LimitExceeded(ref cause) => write!(f, "{}", cause),
PublishSchemaError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
PublishSchemaError::RetryableConflict(ref cause) => write!(f, "{}", cause),
PublishSchemaError::SchemaAlreadyPublished(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PublishSchemaError {}
#[derive(Debug, PartialEq)]
pub enum PutSchemaFromJsonError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidRule(String),
InvalidSchemaDoc(String),
LimitExceeded(String),
RetryableConflict(String),
}
impl PutSchemaFromJsonError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<PutSchemaFromJsonError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(PutSchemaFromJsonError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(PutSchemaFromJsonError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(PutSchemaFromJsonError::InvalidArn(err.msg))
}
"InvalidRuleException" => {
return RusotoError::Service(PutSchemaFromJsonError::InvalidRule(err.msg))
}
"InvalidSchemaDocException" => {
return RusotoError::Service(PutSchemaFromJsonError::InvalidSchemaDoc(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(PutSchemaFromJsonError::LimitExceeded(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(PutSchemaFromJsonError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for PutSchemaFromJsonError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
PutSchemaFromJsonError::AccessDenied(ref cause) => write!(f, "{}", cause),
PutSchemaFromJsonError::InternalService(ref cause) => write!(f, "{}", cause),
PutSchemaFromJsonError::InvalidArn(ref cause) => write!(f, "{}", cause),
PutSchemaFromJsonError::InvalidRule(ref cause) => write!(f, "{}", cause),
PutSchemaFromJsonError::InvalidSchemaDoc(ref cause) => write!(f, "{}", cause),
PutSchemaFromJsonError::LimitExceeded(ref cause) => write!(f, "{}", cause),
PutSchemaFromJsonError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for PutSchemaFromJsonError {}
#[derive(Debug, PartialEq)]
pub enum RemoveFacetFromObjectError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl RemoveFacetFromObjectError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<RemoveFacetFromObjectError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(RemoveFacetFromObjectError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(RemoveFacetFromObjectError::DirectoryNotEnabled(
err.msg,
))
}
"FacetValidationException" => {
return RusotoError::Service(RemoveFacetFromObjectError::FacetValidation(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(RemoveFacetFromObjectError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(RemoveFacetFromObjectError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(RemoveFacetFromObjectError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(RemoveFacetFromObjectError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(RemoveFacetFromObjectError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for RemoveFacetFromObjectError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
RemoveFacetFromObjectError::AccessDenied(ref cause) => write!(f, "{}", cause),
RemoveFacetFromObjectError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
RemoveFacetFromObjectError::FacetValidation(ref cause) => write!(f, "{}", cause),
RemoveFacetFromObjectError::InternalService(ref cause) => write!(f, "{}", cause),
RemoveFacetFromObjectError::InvalidArn(ref cause) => write!(f, "{}", cause),
RemoveFacetFromObjectError::LimitExceeded(ref cause) => write!(f, "{}", cause),
RemoveFacetFromObjectError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
RemoveFacetFromObjectError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for RemoveFacetFromObjectError {}
#[derive(Debug, PartialEq)]
pub enum TagResourceError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidTaggingRequest(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl TagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<TagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(TagResourceError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(TagResourceError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(TagResourceError::InvalidArn(err.msg))
}
"InvalidTaggingRequestException" => {
return RusotoError::Service(TagResourceError::InvalidTaggingRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(TagResourceError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(TagResourceError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(TagResourceError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for TagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
TagResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
TagResourceError::InternalService(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidArn(ref cause) => write!(f, "{}", cause),
TagResourceError::InvalidTaggingRequest(ref cause) => write!(f, "{}", cause),
TagResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
TagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
TagResourceError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for TagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UntagResourceError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
InvalidTaggingRequest(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl UntagResourceError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UntagResourceError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UntagResourceError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(UntagResourceError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(UntagResourceError::InvalidArn(err.msg))
}
"InvalidTaggingRequestException" => {
return RusotoError::Service(UntagResourceError::InvalidTaggingRequest(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UntagResourceError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UntagResourceError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(UntagResourceError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UntagResourceError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UntagResourceError::AccessDenied(ref cause) => write!(f, "{}", cause),
UntagResourceError::InternalService(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidArn(ref cause) => write!(f, "{}", cause),
UntagResourceError::InvalidTaggingRequest(ref cause) => write!(f, "{}", cause),
UntagResourceError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UntagResourceError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UntagResourceError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UntagResourceError {}
#[derive(Debug, PartialEq)]
pub enum UpdateFacetError {
AccessDenied(String),
FacetNotFound(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
InvalidFacetUpdate(String),
InvalidRule(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl UpdateFacetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateFacetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateFacetError::AccessDenied(err.msg))
}
"FacetNotFoundException" => {
return RusotoError::Service(UpdateFacetError::FacetNotFound(err.msg))
}
"FacetValidationException" => {
return RusotoError::Service(UpdateFacetError::FacetValidation(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(UpdateFacetError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(UpdateFacetError::InvalidArn(err.msg))
}
"InvalidFacetUpdateException" => {
return RusotoError::Service(UpdateFacetError::InvalidFacetUpdate(err.msg))
}
"InvalidRuleException" => {
return RusotoError::Service(UpdateFacetError::InvalidRule(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateFacetError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateFacetError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(UpdateFacetError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateFacetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateFacetError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateFacetError::FacetNotFound(ref cause) => write!(f, "{}", cause),
UpdateFacetError::FacetValidation(ref cause) => write!(f, "{}", cause),
UpdateFacetError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateFacetError::InvalidArn(ref cause) => write!(f, "{}", cause),
UpdateFacetError::InvalidFacetUpdate(ref cause) => write!(f, "{}", cause),
UpdateFacetError::InvalidRule(ref cause) => write!(f, "{}", cause),
UpdateFacetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateFacetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateFacetError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateFacetError {}
#[derive(Debug, PartialEq)]
pub enum UpdateLinkAttributesError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl UpdateLinkAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateLinkAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateLinkAttributesError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(UpdateLinkAttributesError::DirectoryNotEnabled(
err.msg,
))
}
"FacetValidationException" => {
return RusotoError::Service(UpdateLinkAttributesError::FacetValidation(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(UpdateLinkAttributesError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(UpdateLinkAttributesError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateLinkAttributesError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateLinkAttributesError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(UpdateLinkAttributesError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateLinkAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateLinkAttributesError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateLinkAttributesError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
UpdateLinkAttributesError::FacetValidation(ref cause) => write!(f, "{}", cause),
UpdateLinkAttributesError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateLinkAttributesError::InvalidArn(ref cause) => write!(f, "{}", cause),
UpdateLinkAttributesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateLinkAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateLinkAttributesError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateLinkAttributesError {}
#[derive(Debug, PartialEq)]
pub enum UpdateObjectAttributesError {
AccessDenied(String),
DirectoryNotEnabled(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
LinkNameAlreadyInUse(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl UpdateObjectAttributesError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateObjectAttributesError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateObjectAttributesError::AccessDenied(err.msg))
}
"DirectoryNotEnabledException" => {
return RusotoError::Service(UpdateObjectAttributesError::DirectoryNotEnabled(
err.msg,
))
}
"FacetValidationException" => {
return RusotoError::Service(UpdateObjectAttributesError::FacetValidation(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(UpdateObjectAttributesError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(UpdateObjectAttributesError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateObjectAttributesError::LimitExceeded(
err.msg,
))
}
"LinkNameAlreadyInUseException" => {
return RusotoError::Service(UpdateObjectAttributesError::LinkNameAlreadyInUse(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateObjectAttributesError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(UpdateObjectAttributesError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateObjectAttributesError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateObjectAttributesError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateObjectAttributesError::DirectoryNotEnabled(ref cause) => write!(f, "{}", cause),
UpdateObjectAttributesError::FacetValidation(ref cause) => write!(f, "{}", cause),
UpdateObjectAttributesError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateObjectAttributesError::InvalidArn(ref cause) => write!(f, "{}", cause),
UpdateObjectAttributesError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateObjectAttributesError::LinkNameAlreadyInUse(ref cause) => write!(f, "{}", cause),
UpdateObjectAttributesError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateObjectAttributesError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateObjectAttributesError {}
#[derive(Debug, PartialEq)]
pub enum UpdateSchemaError {
AccessDenied(String),
InternalService(String),
InvalidArn(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl UpdateSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateSchemaError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateSchemaError::AccessDenied(err.msg))
}
"InternalServiceException" => {
return RusotoError::Service(UpdateSchemaError::InternalService(err.msg))
}
"InvalidArnException" => {
return RusotoError::Service(UpdateSchemaError::InvalidArn(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateSchemaError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateSchemaError::ResourceNotFound(err.msg))
}
"RetryableConflictException" => {
return RusotoError::Service(UpdateSchemaError::RetryableConflict(err.msg))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateSchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateSchemaError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateSchemaError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateSchemaError::InvalidArn(ref cause) => write!(f, "{}", cause),
UpdateSchemaError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateSchemaError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateSchemaError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateSchemaError {}
#[derive(Debug, PartialEq)]
pub enum UpdateTypedLinkFacetError {
AccessDenied(String),
FacetNotFound(String),
FacetValidation(String),
InternalService(String),
InvalidArn(String),
InvalidFacetUpdate(String),
InvalidRule(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl UpdateTypedLinkFacetError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpdateTypedLinkFacetError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpdateTypedLinkFacetError::AccessDenied(err.msg))
}
"FacetNotFoundException" => {
return RusotoError::Service(UpdateTypedLinkFacetError::FacetNotFound(err.msg))
}
"FacetValidationException" => {
return RusotoError::Service(UpdateTypedLinkFacetError::FacetValidation(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(UpdateTypedLinkFacetError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(UpdateTypedLinkFacetError::InvalidArn(err.msg))
}
"InvalidFacetUpdateException" => {
return RusotoError::Service(UpdateTypedLinkFacetError::InvalidFacetUpdate(
err.msg,
))
}
"InvalidRuleException" => {
return RusotoError::Service(UpdateTypedLinkFacetError::InvalidRule(err.msg))
}
"LimitExceededException" => {
return RusotoError::Service(UpdateTypedLinkFacetError::LimitExceeded(err.msg))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpdateTypedLinkFacetError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(UpdateTypedLinkFacetError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpdateTypedLinkFacetError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpdateTypedLinkFacetError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpdateTypedLinkFacetError::FacetNotFound(ref cause) => write!(f, "{}", cause),
UpdateTypedLinkFacetError::FacetValidation(ref cause) => write!(f, "{}", cause),
UpdateTypedLinkFacetError::InternalService(ref cause) => write!(f, "{}", cause),
UpdateTypedLinkFacetError::InvalidArn(ref cause) => write!(f, "{}", cause),
UpdateTypedLinkFacetError::InvalidFacetUpdate(ref cause) => write!(f, "{}", cause),
UpdateTypedLinkFacetError::InvalidRule(ref cause) => write!(f, "{}", cause),
UpdateTypedLinkFacetError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpdateTypedLinkFacetError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpdateTypedLinkFacetError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpdateTypedLinkFacetError {}
#[derive(Debug, PartialEq)]
pub enum UpgradeAppliedSchemaError {
AccessDenied(String),
IncompatibleSchema(String),
InternalService(String),
InvalidArn(String),
InvalidAttachment(String),
ResourceNotFound(String),
RetryableConflict(String),
SchemaAlreadyExists(String),
}
impl UpgradeAppliedSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpgradeAppliedSchemaError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpgradeAppliedSchemaError::AccessDenied(err.msg))
}
"IncompatibleSchemaException" => {
return RusotoError::Service(UpgradeAppliedSchemaError::IncompatibleSchema(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(UpgradeAppliedSchemaError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(UpgradeAppliedSchemaError::InvalidArn(err.msg))
}
"InvalidAttachmentException" => {
return RusotoError::Service(UpgradeAppliedSchemaError::InvalidAttachment(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpgradeAppliedSchemaError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(UpgradeAppliedSchemaError::RetryableConflict(
err.msg,
))
}
"SchemaAlreadyExistsException" => {
return RusotoError::Service(UpgradeAppliedSchemaError::SchemaAlreadyExists(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpgradeAppliedSchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpgradeAppliedSchemaError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpgradeAppliedSchemaError::IncompatibleSchema(ref cause) => write!(f, "{}", cause),
UpgradeAppliedSchemaError::InternalService(ref cause) => write!(f, "{}", cause),
UpgradeAppliedSchemaError::InvalidArn(ref cause) => write!(f, "{}", cause),
UpgradeAppliedSchemaError::InvalidAttachment(ref cause) => write!(f, "{}", cause),
UpgradeAppliedSchemaError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpgradeAppliedSchemaError::RetryableConflict(ref cause) => write!(f, "{}", cause),
UpgradeAppliedSchemaError::SchemaAlreadyExists(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpgradeAppliedSchemaError {}
#[derive(Debug, PartialEq)]
pub enum UpgradePublishedSchemaError {
AccessDenied(String),
IncompatibleSchema(String),
InternalService(String),
InvalidArn(String),
InvalidAttachment(String),
LimitExceeded(String),
ResourceNotFound(String),
RetryableConflict(String),
}
impl UpgradePublishedSchemaError {
pub fn from_response(res: BufferedHttpResponse) -> RusotoError<UpgradePublishedSchemaError> {
if let Some(err) = proto::json::Error::parse_rest(&res) {
match err.typ.as_str() {
"AccessDeniedException" => {
return RusotoError::Service(UpgradePublishedSchemaError::AccessDenied(err.msg))
}
"IncompatibleSchemaException" => {
return RusotoError::Service(UpgradePublishedSchemaError::IncompatibleSchema(
err.msg,
))
}
"InternalServiceException" => {
return RusotoError::Service(UpgradePublishedSchemaError::InternalService(
err.msg,
))
}
"InvalidArnException" => {
return RusotoError::Service(UpgradePublishedSchemaError::InvalidArn(err.msg))
}
"InvalidAttachmentException" => {
return RusotoError::Service(UpgradePublishedSchemaError::InvalidAttachment(
err.msg,
))
}
"LimitExceededException" => {
return RusotoError::Service(UpgradePublishedSchemaError::LimitExceeded(
err.msg,
))
}
"ResourceNotFoundException" => {
return RusotoError::Service(UpgradePublishedSchemaError::ResourceNotFound(
err.msg,
))
}
"RetryableConflictException" => {
return RusotoError::Service(UpgradePublishedSchemaError::RetryableConflict(
err.msg,
))
}
"ValidationException" => return RusotoError::Validation(err.msg),
_ => {}
}
}
RusotoError::Unknown(res)
}
}
impl fmt::Display for UpgradePublishedSchemaError {
#[allow(unused_variables)]
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
match *self {
UpgradePublishedSchemaError::AccessDenied(ref cause) => write!(f, "{}", cause),
UpgradePublishedSchemaError::IncompatibleSchema(ref cause) => write!(f, "{}", cause),
UpgradePublishedSchemaError::InternalService(ref cause) => write!(f, "{}", cause),
UpgradePublishedSchemaError::InvalidArn(ref cause) => write!(f, "{}", cause),
UpgradePublishedSchemaError::InvalidAttachment(ref cause) => write!(f, "{}", cause),
UpgradePublishedSchemaError::LimitExceeded(ref cause) => write!(f, "{}", cause),
UpgradePublishedSchemaError::ResourceNotFound(ref cause) => write!(f, "{}", cause),
UpgradePublishedSchemaError::RetryableConflict(ref cause) => write!(f, "{}", cause),
}
}
}
impl Error for UpgradePublishedSchemaError {}
#[async_trait]
pub trait CloudDirectory {
async fn add_facet_to_object(
&self,
input: AddFacetToObjectRequest,
) -> Result<AddFacetToObjectResponse, RusotoError<AddFacetToObjectError>>;
async fn apply_schema(
&self,
input: ApplySchemaRequest,
) -> Result<ApplySchemaResponse, RusotoError<ApplySchemaError>>;
async fn attach_object(
&self,
input: AttachObjectRequest,
) -> Result<AttachObjectResponse, RusotoError<AttachObjectError>>;
async fn attach_policy(
&self,
input: AttachPolicyRequest,
) -> Result<AttachPolicyResponse, RusotoError<AttachPolicyError>>;
async fn attach_to_index(
&self,
input: AttachToIndexRequest,
) -> Result<AttachToIndexResponse, RusotoError<AttachToIndexError>>;
async fn attach_typed_link(
&self,
input: AttachTypedLinkRequest,
) -> Result<AttachTypedLinkResponse, RusotoError<AttachTypedLinkError>>;
async fn batch_read(
&self,
input: BatchReadRequest,
) -> Result<BatchReadResponse, RusotoError<BatchReadError>>;
async fn batch_write(
&self,
input: BatchWriteRequest,
) -> Result<BatchWriteResponse, RusotoError<BatchWriteError>>;
async fn create_directory(
&self,
input: CreateDirectoryRequest,
) -> Result<CreateDirectoryResponse, RusotoError<CreateDirectoryError>>;
async fn create_facet(
&self,
input: CreateFacetRequest,
) -> Result<CreateFacetResponse, RusotoError<CreateFacetError>>;
async fn create_index(
&self,
input: CreateIndexRequest,
) -> Result<CreateIndexResponse, RusotoError<CreateIndexError>>;
async fn create_object(
&self,
input: CreateObjectRequest,
) -> Result<CreateObjectResponse, RusotoError<CreateObjectError>>;
async fn create_schema(
&self,
input: CreateSchemaRequest,
) -> Result<CreateSchemaResponse, RusotoError<CreateSchemaError>>;
async fn create_typed_link_facet(
&self,
input: CreateTypedLinkFacetRequest,
) -> Result<CreateTypedLinkFacetResponse, RusotoError<CreateTypedLinkFacetError>>;
async fn delete_directory(
&self,
input: DeleteDirectoryRequest,
) -> Result<DeleteDirectoryResponse, RusotoError<DeleteDirectoryError>>;
async fn delete_facet(
&self,
input: DeleteFacetRequest,
) -> Result<DeleteFacetResponse, RusotoError<DeleteFacetError>>;
async fn delete_object(
&self,
input: DeleteObjectRequest,
) -> Result<DeleteObjectResponse, RusotoError<DeleteObjectError>>;
async fn delete_schema(
&self,
input: DeleteSchemaRequest,
) -> Result<DeleteSchemaResponse, RusotoError<DeleteSchemaError>>;
async fn delete_typed_link_facet(
&self,
input: DeleteTypedLinkFacetRequest,
) -> Result<DeleteTypedLinkFacetResponse, RusotoError<DeleteTypedLinkFacetError>>;
async fn detach_from_index(
&self,
input: DetachFromIndexRequest,
) -> Result<DetachFromIndexResponse, RusotoError<DetachFromIndexError>>;
async fn detach_object(
&self,
input: DetachObjectRequest,
) -> Result<DetachObjectResponse, RusotoError<DetachObjectError>>;
async fn detach_policy(
&self,
input: DetachPolicyRequest,
) -> Result<DetachPolicyResponse, RusotoError<DetachPolicyError>>;
async fn detach_typed_link(
&self,
input: DetachTypedLinkRequest,
) -> Result<(), RusotoError<DetachTypedLinkError>>;
async fn disable_directory(
&self,
input: DisableDirectoryRequest,
) -> Result<DisableDirectoryResponse, RusotoError<DisableDirectoryError>>;
async fn enable_directory(
&self,
input: EnableDirectoryRequest,
) -> Result<EnableDirectoryResponse, RusotoError<EnableDirectoryError>>;
async fn get_applied_schema_version(
&self,
input: GetAppliedSchemaVersionRequest,
) -> Result<GetAppliedSchemaVersionResponse, RusotoError<GetAppliedSchemaVersionError>>;
async fn get_directory(
&self,
input: GetDirectoryRequest,
) -> Result<GetDirectoryResponse, RusotoError<GetDirectoryError>>;
async fn get_facet(
&self,
input: GetFacetRequest,
) -> Result<GetFacetResponse, RusotoError<GetFacetError>>;
async fn get_link_attributes(
&self,
input: GetLinkAttributesRequest,
) -> Result<GetLinkAttributesResponse, RusotoError<GetLinkAttributesError>>;
async fn get_object_attributes(
&self,
input: GetObjectAttributesRequest,
) -> Result<GetObjectAttributesResponse, RusotoError<GetObjectAttributesError>>;
async fn get_object_information(
&self,
input: GetObjectInformationRequest,
) -> Result<GetObjectInformationResponse, RusotoError<GetObjectInformationError>>;
async fn get_schema_as_json(
&self,
input: GetSchemaAsJsonRequest,
) -> Result<GetSchemaAsJsonResponse, RusotoError<GetSchemaAsJsonError>>;
async fn get_typed_link_facet_information(
&self,
input: GetTypedLinkFacetInformationRequest,
) -> Result<GetTypedLinkFacetInformationResponse, RusotoError<GetTypedLinkFacetInformationError>>;
async fn list_applied_schema_arns(
&self,
input: ListAppliedSchemaArnsRequest,
) -> Result<ListAppliedSchemaArnsResponse, RusotoError<ListAppliedSchemaArnsError>>;
async fn list_attached_indices(
&self,
input: ListAttachedIndicesRequest,
) -> Result<ListAttachedIndicesResponse, RusotoError<ListAttachedIndicesError>>;
async fn list_development_schema_arns(
&self,
input: ListDevelopmentSchemaArnsRequest,
) -> Result<ListDevelopmentSchemaArnsResponse, RusotoError<ListDevelopmentSchemaArnsError>>;
async fn list_directories(
&self,
input: ListDirectoriesRequest,
) -> Result<ListDirectoriesResponse, RusotoError<ListDirectoriesError>>;
async fn list_facet_attributes(
&self,
input: ListFacetAttributesRequest,
) -> Result<ListFacetAttributesResponse, RusotoError<ListFacetAttributesError>>;
async fn list_facet_names(
&self,
input: ListFacetNamesRequest,
) -> Result<ListFacetNamesResponse, RusotoError<ListFacetNamesError>>;
async fn list_incoming_typed_links(
&self,
input: ListIncomingTypedLinksRequest,
) -> Result<ListIncomingTypedLinksResponse, RusotoError<ListIncomingTypedLinksError>>;
async fn list_index(
&self,
input: ListIndexRequest,
) -> Result<ListIndexResponse, RusotoError<ListIndexError>>;
async fn list_managed_schema_arns(
&self,
input: ListManagedSchemaArnsRequest,
) -> Result<ListManagedSchemaArnsResponse, RusotoError<ListManagedSchemaArnsError>>;
async fn list_object_attributes(
&self,
input: ListObjectAttributesRequest,
) -> Result<ListObjectAttributesResponse, RusotoError<ListObjectAttributesError>>;
async fn list_object_children(
&self,
input: ListObjectChildrenRequest,
) -> Result<ListObjectChildrenResponse, RusotoError<ListObjectChildrenError>>;
async fn list_object_parent_paths(
&self,
input: ListObjectParentPathsRequest,
) -> Result<ListObjectParentPathsResponse, RusotoError<ListObjectParentPathsError>>;
async fn list_object_parents(
&self,
input: ListObjectParentsRequest,
) -> Result<ListObjectParentsResponse, RusotoError<ListObjectParentsError>>;
async fn list_object_policies(
&self,
input: ListObjectPoliciesRequest,
) -> Result<ListObjectPoliciesResponse, RusotoError<ListObjectPoliciesError>>;
async fn list_outgoing_typed_links(
&self,
input: ListOutgoingTypedLinksRequest,
) -> Result<ListOutgoingTypedLinksResponse, RusotoError<ListOutgoingTypedLinksError>>;
async fn list_policy_attachments(
&self,
input: ListPolicyAttachmentsRequest,
) -> Result<ListPolicyAttachmentsResponse, RusotoError<ListPolicyAttachmentsError>>;
async fn list_published_schema_arns(
&self,
input: ListPublishedSchemaArnsRequest,
) -> Result<ListPublishedSchemaArnsResponse, RusotoError<ListPublishedSchemaArnsError>>;
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>>;
async fn list_typed_link_facet_attributes(
&self,
input: ListTypedLinkFacetAttributesRequest,
) -> Result<ListTypedLinkFacetAttributesResponse, RusotoError<ListTypedLinkFacetAttributesError>>;
async fn list_typed_link_facet_names(
&self,
input: ListTypedLinkFacetNamesRequest,
) -> Result<ListTypedLinkFacetNamesResponse, RusotoError<ListTypedLinkFacetNamesError>>;
async fn lookup_policy(
&self,
input: LookupPolicyRequest,
) -> Result<LookupPolicyResponse, RusotoError<LookupPolicyError>>;
async fn publish_schema(
&self,
input: PublishSchemaRequest,
) -> Result<PublishSchemaResponse, RusotoError<PublishSchemaError>>;
async fn put_schema_from_json(
&self,
input: PutSchemaFromJsonRequest,
) -> Result<PutSchemaFromJsonResponse, RusotoError<PutSchemaFromJsonError>>;
async fn remove_facet_from_object(
&self,
input: RemoveFacetFromObjectRequest,
) -> Result<RemoveFacetFromObjectResponse, RusotoError<RemoveFacetFromObjectError>>;
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>>;
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>>;
async fn update_facet(
&self,
input: UpdateFacetRequest,
) -> Result<UpdateFacetResponse, RusotoError<UpdateFacetError>>;
async fn update_link_attributes(
&self,
input: UpdateLinkAttributesRequest,
) -> Result<UpdateLinkAttributesResponse, RusotoError<UpdateLinkAttributesError>>;
async fn update_object_attributes(
&self,
input: UpdateObjectAttributesRequest,
) -> Result<UpdateObjectAttributesResponse, RusotoError<UpdateObjectAttributesError>>;
async fn update_schema(
&self,
input: UpdateSchemaRequest,
) -> Result<UpdateSchemaResponse, RusotoError<UpdateSchemaError>>;
async fn update_typed_link_facet(
&self,
input: UpdateTypedLinkFacetRequest,
) -> Result<UpdateTypedLinkFacetResponse, RusotoError<UpdateTypedLinkFacetError>>;
async fn upgrade_applied_schema(
&self,
input: UpgradeAppliedSchemaRequest,
) -> Result<UpgradeAppliedSchemaResponse, RusotoError<UpgradeAppliedSchemaError>>;
async fn upgrade_published_schema(
&self,
input: UpgradePublishedSchemaRequest,
) -> Result<UpgradePublishedSchemaResponse, RusotoError<UpgradePublishedSchemaError>>;
}
#[derive(Clone)]
pub struct CloudDirectoryClient {
client: Client,
region: region::Region,
}
impl CloudDirectoryClient {
pub fn new(region: region::Region) -> CloudDirectoryClient {
CloudDirectoryClient {
client: Client::shared(),
region,
}
}
pub fn new_with<P, D>(
request_dispatcher: D,
credentials_provider: P,
region: region::Region,
) -> CloudDirectoryClient
where
P: ProvideAwsCredentials + Send + Sync + 'static,
D: DispatchSignedRequest + Send + Sync + 'static,
{
CloudDirectoryClient {
client: Client::new_with(credentials_provider, request_dispatcher),
region,
}
}
pub fn new_with_client(client: Client, region: region::Region) -> CloudDirectoryClient {
CloudDirectoryClient { client, region }
}
}
#[async_trait]
impl CloudDirectory for CloudDirectoryClient {
#[allow(unused_mut)]
async fn add_facet_to_object(
&self,
input: AddFacetToObjectRequest,
) -> Result<AddFacetToObjectResponse, RusotoError<AddFacetToObjectError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/facets";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AddFacetToObjectResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AddFacetToObjectError::from_response(response))
}
}
#[allow(unused_mut)]
async fn apply_schema(
&self,
input: ApplySchemaRequest,
) -> Result<ApplySchemaResponse, RusotoError<ApplySchemaError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/apply";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ApplySchemaResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ApplySchemaError::from_response(response))
}
}
#[allow(unused_mut)]
async fn attach_object(
&self,
input: AttachObjectRequest,
) -> Result<AttachObjectResponse, RusotoError<AttachObjectError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/attach";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AttachObjectResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AttachObjectError::from_response(response))
}
}
#[allow(unused_mut)]
async fn attach_policy(
&self,
input: AttachPolicyRequest,
) -> Result<AttachPolicyResponse, RusotoError<AttachPolicyError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/policy/attach";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AttachPolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AttachPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn attach_to_index(
&self,
input: AttachToIndexRequest,
) -> Result<AttachToIndexResponse, RusotoError<AttachToIndexError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/index/attach";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AttachToIndexResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AttachToIndexError::from_response(response))
}
}
#[allow(unused_mut)]
async fn attach_typed_link(
&self,
input: AttachTypedLinkRequest,
) -> Result<AttachTypedLinkResponse, RusotoError<AttachTypedLinkError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/attach";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<AttachTypedLinkResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(AttachTypedLinkError::from_response(response))
}
}
#[allow(unused_mut)]
async fn batch_read(
&self,
input: BatchReadRequest,
) -> Result<BatchReadResponse, RusotoError<BatchReadError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/batchread";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("x-amz-consistency-level", input.consistency_level.as_ref());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<BatchReadResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(BatchReadError::from_response(response))
}
}
#[allow(unused_mut)]
async fn batch_write(
&self,
input: BatchWriteRequest,
) -> Result<BatchWriteResponse, RusotoError<BatchWriteError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/batchwrite";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<BatchWriteResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(BatchWriteError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_directory(
&self,
input: CreateDirectoryRequest,
) -> Result<CreateDirectoryResponse, RusotoError<CreateDirectoryError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/directory/create";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateDirectoryResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateDirectoryError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_facet(
&self,
input: CreateFacetRequest,
) -> Result<CreateFacetResponse, RusotoError<CreateFacetError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/facet/create";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateFacetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateFacetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_index(
&self,
input: CreateIndexRequest,
) -> Result<CreateIndexResponse, RusotoError<CreateIndexError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/index";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateIndexResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateIndexError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_object(
&self,
input: CreateObjectRequest,
) -> Result<CreateObjectResponse, RusotoError<CreateObjectError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateObjectResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateObjectError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_schema(
&self,
input: CreateSchemaRequest,
) -> Result<CreateSchemaResponse, RusotoError<CreateSchemaError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/create";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateSchemaResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateSchemaError::from_response(response))
}
}
#[allow(unused_mut)]
async fn create_typed_link_facet(
&self,
input: CreateTypedLinkFacetRequest,
) -> Result<CreateTypedLinkFacetResponse, RusotoError<CreateTypedLinkFacetError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/facet/create";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<CreateTypedLinkFacetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(CreateTypedLinkFacetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_directory(
&self,
input: DeleteDirectoryRequest,
) -> Result<DeleteDirectoryResponse, RusotoError<DeleteDirectoryError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/directory";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteDirectoryResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteDirectoryError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_facet(
&self,
input: DeleteFacetRequest,
) -> Result<DeleteFacetResponse, RusotoError<DeleteFacetError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/facet/delete";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteFacetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteFacetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_object(
&self,
input: DeleteObjectRequest,
) -> Result<DeleteObjectResponse, RusotoError<DeleteObjectError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/delete";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteObjectResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteObjectError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_schema(
&self,
input: DeleteSchemaRequest,
) -> Result<DeleteSchemaResponse, RusotoError<DeleteSchemaError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteSchemaResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteSchemaError::from_response(response))
}
}
#[allow(unused_mut)]
async fn delete_typed_link_facet(
&self,
input: DeleteTypedLinkFacetRequest,
) -> Result<DeleteTypedLinkFacetResponse, RusotoError<DeleteTypedLinkFacetError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/facet/delete";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DeleteTypedLinkFacetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DeleteTypedLinkFacetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn detach_from_index(
&self,
input: DetachFromIndexRequest,
) -> Result<DetachFromIndexResponse, RusotoError<DetachFromIndexError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/index/detach";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DetachFromIndexResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DetachFromIndexError::from_response(response))
}
}
#[allow(unused_mut)]
async fn detach_object(
&self,
input: DetachObjectRequest,
) -> Result<DetachObjectResponse, RusotoError<DetachObjectError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/detach";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DetachObjectResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DetachObjectError::from_response(response))
}
}
#[allow(unused_mut)]
async fn detach_policy(
&self,
input: DetachPolicyRequest,
) -> Result<DetachPolicyResponse, RusotoError<DetachPolicyError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/policy/detach";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DetachPolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DetachPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn detach_typed_link(
&self,
input: DetachTypedLinkRequest,
) -> Result<(), RusotoError<DetachTypedLinkError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/detach";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = ::std::mem::drop(response);
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DetachTypedLinkError::from_response(response))
}
}
#[allow(unused_mut)]
async fn disable_directory(
&self,
input: DisableDirectoryRequest,
) -> Result<DisableDirectoryResponse, RusotoError<DisableDirectoryError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/directory/disable";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<DisableDirectoryResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(DisableDirectoryError::from_response(response))
}
}
#[allow(unused_mut)]
async fn enable_directory(
&self,
input: EnableDirectoryRequest,
) -> Result<EnableDirectoryResponse, RusotoError<EnableDirectoryError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/directory/enable";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<EnableDirectoryResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(EnableDirectoryError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_applied_schema_version(
&self,
input: GetAppliedSchemaVersionRequest,
) -> Result<GetAppliedSchemaVersionResponse, RusotoError<GetAppliedSchemaVersionError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/getappliedschema";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetAppliedSchemaVersionResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetAppliedSchemaVersionError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_directory(
&self,
input: GetDirectoryRequest,
) -> Result<GetDirectoryResponse, RusotoError<GetDirectoryError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/directory/get";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetDirectoryResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetDirectoryError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_facet(
&self,
input: GetFacetRequest,
) -> Result<GetFacetResponse, RusotoError<GetFacetError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/facet";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetFacetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetFacetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_link_attributes(
&self,
input: GetLinkAttributesRequest,
) -> Result<GetLinkAttributesResponse, RusotoError<GetLinkAttributesError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/attributes/get";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetLinkAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetLinkAttributesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_object_attributes(
&self,
input: GetObjectAttributesRequest,
) -> Result<GetObjectAttributesResponse, RusotoError<GetObjectAttributesError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/attributes/get";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("x-amz-consistency-level", input.consistency_level.as_ref());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetObjectAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetObjectAttributesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_object_information(
&self,
input: GetObjectInformationRequest,
) -> Result<GetObjectInformationResponse, RusotoError<GetObjectInformationError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/information";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("x-amz-consistency-level", input.consistency_level.as_ref());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetObjectInformationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetObjectInformationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_schema_as_json(
&self,
input: GetSchemaAsJsonRequest,
) -> Result<GetSchemaAsJsonResponse, RusotoError<GetSchemaAsJsonError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/json";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetSchemaAsJsonResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetSchemaAsJsonError::from_response(response))
}
}
#[allow(unused_mut)]
async fn get_typed_link_facet_information(
&self,
input: GetTypedLinkFacetInformationRequest,
) -> Result<GetTypedLinkFacetInformationResponse, RusotoError<GetTypedLinkFacetInformationError>>
{
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/facet/get";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<GetTypedLinkFacetInformationResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(GetTypedLinkFacetInformationError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_applied_schema_arns(
&self,
input: ListAppliedSchemaArnsRequest,
) -> Result<ListAppliedSchemaArnsResponse, RusotoError<ListAppliedSchemaArnsError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/applied";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListAppliedSchemaArnsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListAppliedSchemaArnsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_attached_indices(
&self,
input: ListAttachedIndicesRequest,
) -> Result<ListAttachedIndicesResponse, RusotoError<ListAttachedIndicesError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/indices";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("x-amz-consistency-level", input.consistency_level.as_ref());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListAttachedIndicesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListAttachedIndicesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_development_schema_arns(
&self,
input: ListDevelopmentSchemaArnsRequest,
) -> Result<ListDevelopmentSchemaArnsResponse, RusotoError<ListDevelopmentSchemaArnsError>>
{
let request_uri = "/amazonclouddirectory/2017-01-11/schema/development";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDevelopmentSchemaArnsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDevelopmentSchemaArnsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_directories(
&self,
input: ListDirectoriesRequest,
) -> Result<ListDirectoriesResponse, RusotoError<ListDirectoriesError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/directory/list";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListDirectoriesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListDirectoriesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_facet_attributes(
&self,
input: ListFacetAttributesRequest,
) -> Result<ListFacetAttributesResponse, RusotoError<ListFacetAttributesError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/facet/attributes";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFacetAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFacetAttributesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_facet_names(
&self,
input: ListFacetNamesRequest,
) -> Result<ListFacetNamesResponse, RusotoError<ListFacetNamesError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/facet/list";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListFacetNamesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListFacetNamesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_incoming_typed_links(
&self,
input: ListIncomingTypedLinksRequest,
) -> Result<ListIncomingTypedLinksResponse, RusotoError<ListIncomingTypedLinksError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/incoming";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListIncomingTypedLinksResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListIncomingTypedLinksError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_index(
&self,
input: ListIndexRequest,
) -> Result<ListIndexResponse, RusotoError<ListIndexError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/index/targets";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("x-amz-consistency-level", input.consistency_level.as_ref());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListIndexResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListIndexError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_managed_schema_arns(
&self,
input: ListManagedSchemaArnsRequest,
) -> Result<ListManagedSchemaArnsResponse, RusotoError<ListManagedSchemaArnsError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/managed";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListManagedSchemaArnsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListManagedSchemaArnsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_object_attributes(
&self,
input: ListObjectAttributesRequest,
) -> Result<ListObjectAttributesResponse, RusotoError<ListObjectAttributesError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/attributes";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("x-amz-consistency-level", input.consistency_level.as_ref());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListObjectAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListObjectAttributesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_object_children(
&self,
input: ListObjectChildrenRequest,
) -> Result<ListObjectChildrenResponse, RusotoError<ListObjectChildrenError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/children";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("x-amz-consistency-level", input.consistency_level.as_ref());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListObjectChildrenResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListObjectChildrenError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_object_parent_paths(
&self,
input: ListObjectParentPathsRequest,
) -> Result<ListObjectParentPathsResponse, RusotoError<ListObjectParentPathsError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/parentpaths";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListObjectParentPathsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListObjectParentPathsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_object_parents(
&self,
input: ListObjectParentsRequest,
) -> Result<ListObjectParentsResponse, RusotoError<ListObjectParentsError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/parent";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("x-amz-consistency-level", input.consistency_level.as_ref());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListObjectParentsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListObjectParentsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_object_policies(
&self,
input: ListObjectPoliciesRequest,
) -> Result<ListObjectPoliciesResponse, RusotoError<ListObjectPoliciesError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/policy";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("x-amz-consistency-level", input.consistency_level.as_ref());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListObjectPoliciesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListObjectPoliciesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_outgoing_typed_links(
&self,
input: ListOutgoingTypedLinksRequest,
) -> Result<ListOutgoingTypedLinksResponse, RusotoError<ListOutgoingTypedLinksError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/outgoing";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListOutgoingTypedLinksResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListOutgoingTypedLinksError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_policy_attachments(
&self,
input: ListPolicyAttachmentsRequest,
) -> Result<ListPolicyAttachmentsResponse, RusotoError<ListPolicyAttachmentsError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/policy/attachment";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_optional_header("x-amz-consistency-level", input.consistency_level.as_ref());
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPolicyAttachmentsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPolicyAttachmentsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_published_schema_arns(
&self,
input: ListPublishedSchemaArnsRequest,
) -> Result<ListPublishedSchemaArnsResponse, RusotoError<ListPublishedSchemaArnsError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/published";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListPublishedSchemaArnsResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListPublishedSchemaArnsError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_tags_for_resource(
&self,
input: ListTagsForResourceRequest,
) -> Result<ListTagsForResourceResponse, RusotoError<ListTagsForResourceError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/tags";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTagsForResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTagsForResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_typed_link_facet_attributes(
&self,
input: ListTypedLinkFacetAttributesRequest,
) -> Result<ListTypedLinkFacetAttributesResponse, RusotoError<ListTypedLinkFacetAttributesError>>
{
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/facet/attributes";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTypedLinkFacetAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTypedLinkFacetAttributesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn list_typed_link_facet_names(
&self,
input: ListTypedLinkFacetNamesRequest,
) -> Result<ListTypedLinkFacetNamesResponse, RusotoError<ListTypedLinkFacetNamesError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/facet/list";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<ListTypedLinkFacetNamesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(ListTypedLinkFacetNamesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn lookup_policy(
&self,
input: LookupPolicyRequest,
) -> Result<LookupPolicyResponse, RusotoError<LookupPolicyError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/policy/lookup";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<LookupPolicyResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(LookupPolicyError::from_response(response))
}
}
#[allow(unused_mut)]
async fn publish_schema(
&self,
input: PublishSchemaRequest,
) -> Result<PublishSchemaResponse, RusotoError<PublishSchemaError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/publish";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header(
"x-amz-data-partition",
&input.development_schema_arn.to_string(),
);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PublishSchemaResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PublishSchemaError::from_response(response))
}
}
#[allow(unused_mut)]
async fn put_schema_from_json(
&self,
input: PutSchemaFromJsonRequest,
) -> Result<PutSchemaFromJsonResponse, RusotoError<PutSchemaFromJsonError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/json";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<PutSchemaFromJsonResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(PutSchemaFromJsonError::from_response(response))
}
}
#[allow(unused_mut)]
async fn remove_facet_from_object(
&self,
input: RemoveFacetFromObjectRequest,
) -> Result<RemoveFacetFromObjectResponse, RusotoError<RemoveFacetFromObjectError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/facets/delete";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<RemoveFacetFromObjectResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(RemoveFacetFromObjectError::from_response(response))
}
}
#[allow(unused_mut)]
async fn tag_resource(
&self,
input: TagResourceRequest,
) -> Result<TagResourceResponse, RusotoError<TagResourceError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/tags/add";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<TagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(TagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn untag_resource(
&self,
input: UntagResourceRequest,
) -> Result<UntagResourceResponse, RusotoError<UntagResourceError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/tags/remove";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UntagResourceResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UntagResourceError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_facet(
&self,
input: UpdateFacetRequest,
) -> Result<UpdateFacetResponse, RusotoError<UpdateFacetError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/facet";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateFacetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateFacetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_link_attributes(
&self,
input: UpdateLinkAttributesRequest,
) -> Result<UpdateLinkAttributesResponse, RusotoError<UpdateLinkAttributesError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/attributes/update";
let mut request = SignedRequest::new("POST", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateLinkAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateLinkAttributesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_object_attributes(
&self,
input: UpdateObjectAttributesRequest,
) -> Result<UpdateObjectAttributesResponse, RusotoError<UpdateObjectAttributesError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/object/update";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.directory_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateObjectAttributesResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateObjectAttributesError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_schema(
&self,
input: UpdateSchemaRequest,
) -> Result<UpdateSchemaResponse, RusotoError<UpdateSchemaError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/update";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateSchemaResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateSchemaError::from_response(response))
}
}
#[allow(unused_mut)]
async fn update_typed_link_facet(
&self,
input: UpdateTypedLinkFacetRequest,
) -> Result<UpdateTypedLinkFacetResponse, RusotoError<UpdateTypedLinkFacetError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/typedlink/facet";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
request.add_header("x-amz-data-partition", &input.schema_arn.to_string());
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpdateTypedLinkFacetResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpdateTypedLinkFacetError::from_response(response))
}
}
#[allow(unused_mut)]
async fn upgrade_applied_schema(
&self,
input: UpgradeAppliedSchemaRequest,
) -> Result<UpgradeAppliedSchemaResponse, RusotoError<UpgradeAppliedSchemaError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/upgradeapplied";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpgradeAppliedSchemaResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpgradeAppliedSchemaError::from_response(response))
}
}
#[allow(unused_mut)]
async fn upgrade_published_schema(
&self,
input: UpgradePublishedSchemaRequest,
) -> Result<UpgradePublishedSchemaResponse, RusotoError<UpgradePublishedSchemaError>> {
let request_uri = "/amazonclouddirectory/2017-01-11/schema/upgradepublished";
let mut request = SignedRequest::new("PUT", "clouddirectory", &self.region, &request_uri);
request.set_content_type("application/x-amz-json-1.1".to_owned());
let encoded = Some(serde_json::to_vec(&input).unwrap());
request.set_payload(encoded);
let mut response = self
.client
.sign_and_dispatch(request)
.await
.map_err(RusotoError::from)?;
if response.status.as_u16() == 200 {
let mut response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
let result = proto::json::ResponsePayload::new(&response)
.deserialize::<UpgradePublishedSchemaResponse, _>()?;
Ok(result)
} else {
let response = response.buffer().await.map_err(RusotoError::HttpDispatch)?;
Err(UpgradePublishedSchemaError::from_response(response))
}
}
}