minio-rsc 0.2.6

//! Data types

mod select_object_content;

pub use select_object_content::*;

use serde::{Deserialize, Serialize};

use crate::time::UtcTime;

#[derive(Clone, Debug, PartialEq)]
pub struct Region(pub String);

trait XmlSelf {}

macro_rules! impl_xmlself {
    ($($name:tt )*) => {
        $(
            impl XmlSelf for $name{}
        )*
    };
}

impl_xmlself!(
    CommonPrefix
    LegalHold
    VersioningConfiguration
    Retention
    CompleteMultipartUpload
    CompleteMultipartUploadResult
    InitiateMultipartUploadResult
    ListMultipartUploadsResult
    CopyPartResult
    ListPartsResult
    ListAllMyBucketsResult
    ListBucketResult
    ListVersionsResult
    ServerSideEncryptionConfiguration
    CORSConfiguration
    LocationConstraint
    PublicAccessBlockConfiguration
    AccessControlPolicy
    ReplicationConfiguration
    WebsiteConfiguration
    LifecycleConfiguration
    PolicyStatus
    AnalyticsConfiguration
);

pub trait ToXml {
    /// try get xml string
    fn to_xml(&self) -> crate::error::Result<String>;
}

impl<T: Serialize + XmlSelf> ToXml for T {
    fn to_xml(&self) -> crate::error::Result<String> {
        crate::xml::ser::to_string(&self).map_err(Into::into)
    }
}

pub trait FromXml: Sized {
    /// try from xml string
    fn from_xml(v: String) -> crate::error::Result<Self>;
}

impl<'de, T: Deserialize<'de> + XmlSelf> FromXml for T {
    fn from_xml(v: String) -> crate::error::Result<Self> {
        crate::xml::de::from_string(v).map_err(Into::into)
    }
}

impl Region {
    pub fn from<S>(region: S) -> Self
    where
        S: Into<String>,
    {
        return Self(region.into());
    }

    pub fn as_str(&self) -> &str {
        self.0.as_str()
    }
}

/// Specifies the days since the initiation of an incomplete multipart upload
/// that Amazon S3 will wait before permanently removing all parts of the upload.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AbortIncompleteMultipartUpload {
    /// Specifies the number of days after which Amazon S3 aborts an incomplete multipart upload.
    pub days_after_initiation: i32,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AccessControlList {
    /// Array of [Grant]
    pub grant: Vec<Grant>,
}

/// Contains the elements that set the ACL permissions for an object per grantee.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AccessControlPolicy {
    pub access_control_list: AccessControlList,
    pub owner: Option<Owner>,
}

/// A container for information about access control for replicas.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AccessControlTranslation {
    pub owner: String,
}

///A conjunction (logical AND) of predicates, which is used in evaluating a metrics filter.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AnalyticsAndOperator {
    /// The prefix to use when evaluating an AND predicate:
    /// The prefix that an object must have to be included in the metrics results.
    pub prefix: Option<String>,
    /// The list of tags to use when evaluating an AND predicate.
    #[serde(rename = "tag", default)]
    pub tags: Vec<Tag>,
}

/// AnalyticsConfiguration parameters.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AnalyticsConfiguration {
    /// The ID that identifies the analytics configuration.
    pub id: String,
    /// Contains data related to access patterns to be collected and made available to analyze the tradeoffs between different storage classes.
    pub storage_class_analysis: StorageClassAnalysis,
    /// The filter used to describe a set of objects for analyses.
    pub filter: AnalyticsFilter,
}

/// Where to publish the analytics results.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AnalyticsExportDestination {
    pub s3_bucket_destination: AnalyticsS3BucketDestination,
}

/// The filter used to describe a set of objects for analyses.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AnalyticsFilter {
    /// The prefix to use when evaluating an analytics filter.
    pub prefix: Option<String>,
    /// A conjunction (logical AND) of predicates, which is used in evaluating an analytics filter.
    /// The operator must have at least two predicates.
    pub and: Option<AnalyticsAndOperator>,
    /// The filter used to describe a set of objects for analyses.
    pub tag: Tag,
}
/// Contains information about where to publish the analytics results.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct AnalyticsS3BucketDestination {
    /// The Amazon Resource Name (ARN) of the bucket to which data is exported.
    pub bucket: String,
    /// Specifies the file format used when exporting data to Amazon S3.
    /// Valid Values: CSV
    pub format: String,
    /// The account ID that owns the destination bucket.
    pub bucket_account_id: Option<String>,
    /// The prefix to use when exporting data. The prefix is prepended to all results.
    pub prefix: Option<String>,
}

/// In terms of implementation, a Bucket is a resource.
/// An Amazon S3 bucket name is globally unique, and the namespace is shared by all AWS accounts.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Bucket {
    /// The name of the bucket.
    pub name: String,
    /// Date the bucket was created. This date can change when making changes to your bucket, such as editing its bucket policy.
    pub creation_date: String,
}

#[derive(Clone, Debug, Default, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Buckets {
    #[serde(default)]
    pub bucket: Vec<Bucket>,
}

/// Container for all (if there are any) keys between Prefix and the next occurrence of the string specified by a delimiter.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct CommonPrefix {
    pub prefix: String,
}

/// The container for the completed multipart upload details.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct CompleteMultipartUpload {
    #[serde(default, rename = "Part")]
    pub parts: Vec<Part>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct CompleteMultipartUploadResult {
    pub bucket: String,
    pub key: String,
    pub e_tag: String,
    pub location: String,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Condition {
    pub http_error_code_returned_equals: Option<String>,
    pub key_prefix_equals: Option<String>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct CopyPartResult {
    pub e_tag: String,
}

/// Describes the cross-origin access configuration for objects in an Amazon S3 bucket.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct CORSConfiguration {
    #[serde(rename = "CORSRule")]
    pub rules: Vec<CORSRule>,
}

/// Specifies a cross-origin access rule for an Amazon S3 bucket.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "PascalCase")]
pub struct CORSRule {
    /// **Required**. Valid values are `GET`, `PUT`, `HEAD`, `POST`, and `DELETE`.
    #[serde(rename = "AllowedMethod", default)]
    pub allowed_methods: Vec<String>,
    /// **Required**
    #[serde(rename = "AllowedOrigin", default)]
    pub allowed_origins: Vec<String>,
    #[serde(rename = "AllowedHeader", default)]
    pub allowed_headers: Vec<String>,
    #[serde(rename = "ExposeHeader", default)]
    pub expose_headers: Vec<String>,
    #[serde(rename = "ID")]
    pub id: Option<String>,
    pub max_age_seconds: usize,
}

/// The container element for specifying the default Object Lock retention settings
/// for new objects placed in the specified bucket.
///
/// **Note**
/// - The DefaultRetention settings require **both** a `mode` and a `period`.
/// - The DefaultRetention period can be either Days or Years but you must select one.
///   You cannot specify Days and Years at the same time.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "PascalCase")]
pub struct DefaultRetention {
    pub days: Option<usize>,
    pub mode: RetentionMode,
    pub years: Option<usize>,
}

/// Information about the delete marker.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct DeleteMarkerEntry {
    /// The object key.
    pub key: String,
    /// Date and time when the object was last modified.
    pub last_modified: String,
    /// Specifies whether the object is (true) or is not (false) the latest version of an object.
    pub is_latest: bool,
    /// The entity tag is an MD5 hash of that version of the object.
    pub owner: Option<Owner>,
    /// Version ID of an object.
    pub version_id: Option<String>,
}

/// Specifies whether Amazon S3 replicates delete markers.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct DeleteMarkerReplication {
    pub status: Status,
}

/// Specifies information about where to publish analysis or configuration results for an Amazon S3 bucket and S3 Replication Time Control (S3 RTC).
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Destination {
    pub bucket: String,
    pub account: Option<String>,
    pub storage_class: StorageClass,
    pub access_control_translation: Option<AccessControlTranslation>,
    pub encryption_configuration: Option<EncryptionConfiguration>,
    pub replication_time: Option<ReplicationTime>,
    pub metrics: Option<Metrics>,
}

/// Specifies encryption-related information for an Amazon S3 bucket that is a destination for replicated objects.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct EncryptionConfiguration {
    #[serde(rename = "ReplicaKmsKeyID")]
    pub replica_kms_key_id: String,
}

/// The error information.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ErrorDocument {
    /// The object key name to use when a 4XX class error occurs.
    /// Minimum length of 1.
    pub key: String,
}

/// Optional configuration to replicate existing source bucket objects.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ExistingObjectReplication {
    pub status: Status,
}

/// Container for grant information.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Grant {
    pub grantee: Option<Grantee>,
    pub permission: Option<Permission>,
}

/// Container for the person being granted permissions.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Grantee {
    pub display_name: Option<String>,
    pub email_address: Option<String>,
    pub id: Option<String>,
    #[serde(alias = "Type", alias = "type")]
    pub r#type: GranteeType,
    pub uri: Option<String>,
}

/// The name of the index document for the website.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct IndexDocument {
    /// A suffix that is appended to a request that is for a directory on the website endpoint.
    pub suffix: String,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub(crate) struct InitiateMultipartUploadResult {
    pub bucket: String,
    pub key: String,
    pub upload_id: String,
}

/// Container element that identifies who initiated the multipart upload.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Initiator {
    /// Name of the Principal.
    pub display_name: String,
    #[serde(rename = "ID")]
    pub id: String,
}

/// A legal hold configuration for an object.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct LegalHold {
    pub status: LegalHoldStatus,
}

///  LifecycleConfiguration parameters.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct LifecycleConfiguration {
    pub rule: Vec<LifecycleRule>,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct LifecycleExpiration {
    pub date: Option<String>,
    /// Indicates the lifetime, in days, of the objects that are subject to the rule.
    /// The value must be a non-zero positive integer.
    pub days: u32,
    pub expired_object_delete_marker: Option<bool>,
}

/// A lifecycle rule for individual objects in an Amazon S3 bucket.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct LifecycleRule {
    /// Unique identifier for the rule. The value cannot be longer than 255 characters.
    #[serde(rename = "ID")]
    pub id: Option<String>,

    pub prefix: Option<String>,
    /// If 'Enabled', the rule is currently being applied. If 'Disabled', the rule is not currently being applied.
    pub status: Status,
    /// Specifies the days since the initiation of an incomplete multipart upload
    /// that Amazon S3 will wait before permanently removing all parts of the upload.
    pub abort_incomplete_multipart_upload: Option<AbortIncompleteMultipartUpload>,
    /// Specifies the expiration for the lifecycle of the object in the form of date, days and, whether the object has a delete marker.
    pub expiration: Option<LifecycleExpiration>,
    /// The Filter is used to identify objects that a Lifecycle Rule applies to.
    pub filter: Option<LifecycleRuleFilter>,
    /// Specifies when noncurrent object versions expire.
    pub noncurrent_version_expiration: Option<NoncurrentVersionExpiration>,
    /// Specifies the transition rule for the lifecycle rule that describes when noncurrent objects transition to a specific storage class.
    #[serde(rename = "NoncurrentVersionTransition", default)]
    pub noncurrent_version_transitions: Vec<NoncurrentVersionTransition>,
    /// Specifies when an Amazon S3 object transitions to a specified storage class.
    #[serde(rename = "Transition", default)]
    pub transitions: Vec<Transition>,
}

/// This is used in a Lifecycle Rule Filter to apply a logical AND to two or more predicates.
/// The Lifecycle Rule will apply to any object matching all of the predicates configured inside the And operator.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct LifecycleRuleAndOperator {
    /// Minimum object size to which the rule applies.
    pub object_size_greater_than: Option<u32>,
    /// Maximum object size to which the rule applies.
    pub object_size_less_than: Option<u32>,
    /// Prefix identifying one or more objects to which the rule applies.
    pub prefix: Option<String>,
    /// All of these tags must exist in the object's tag set in order for the rule to apply.
    #[serde(rename = "tag", default)]
    pub tags: Vec<Tag>,
}

/// The Filter is used to identify objects that a Lifecycle Rule applies to.
/// A Filter can have exactly one of Prefix, Tag, ObjectSizeGreaterThan,
/// ObjectSizeLessThan, or And specified. If the Filter element is left empty,
/// the Lifecycle Rule applies to all objects in the bucket.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct LifecycleRuleFilter {
    /// This is used in a Lifecycle Rule Filter to apply a logical AND to two or more predicates.
    /// The Lifecycle Rule will apply to any object matching all of the predicates configured inside the And operator.
    pub and: Option<LifecycleRuleAndOperator>,
    /// Minimum object size to which the rule applies.
    pub object_size_greater_than: Option<u32>,
    /// Maximum object size to which the rule applies.
    pub object_size_less_than: Option<u32>,
    /// Prefix identifying one or more objects to which the rule applies.
    pub prefix: Option<String>,
    /// This tag must exist in the object's tag set in order for the rule to apply.
    pub tag: Option<Tag>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ListAllMyBucketsResult {
    #[serde(default)]
    pub buckets: Buckets,
    pub owner: Owner,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ListBucketResult {
    pub name: String,
    pub prefix: String,
    pub key_count: usize,
    pub max_keys: usize,
    #[serde(default)]
    pub delimiter: String,
    pub is_truncated: bool,
    pub start_after: Option<String>,
    #[serde(default)]
    pub contents: Vec<Object>,
    #[serde(default)]
    pub common_prefixes: Vec<CommonPrefix>,
    #[serde(default)]
    pub next_continuation_token: String,
    #[serde(default)]
    pub continuation_token: String,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ListMultipartUploadsResult {
    pub bucket: String,
    pub key_marker: String,
    pub upload_id_marker: String,
    pub next_key_marker: String,
    pub prefix: String,
    pub delimiter: String,
    pub next_upload_id_marker: String,
    pub max_uploads: usize,
    pub is_truncated: bool,
    #[serde(default, rename = "Upload")]
    pub uploads: Vec<MultipartUpload>,
    #[serde(default)]
    pub common_prefixes: Vec<CommonPrefix>,
    pub encoding_type: Option<String>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ListPartsResult {
    pub bucket: String,
    pub key: String,
    pub upload_id: String,
    pub part_number_marker: usize,
    pub max_parts: usize,
    pub next_part_number_marker: usize,
    pub is_truncated: bool,
    #[serde(default, rename = "Part")]
    pub parts: Vec<Part>,
    pub storage_class: String,
    pub checksum_algorithm: String,
    pub initiator: Initiator,
    pub owner: Owner,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ListVersionsResult {
    /// A flag that indicates whether Amazon S3 returned all of the results
    /// that satisfied the search criteria. If your results were truncated,
    /// you can make a follow-up paginated request by using the `NextKeyMarker`
    /// and `NextVersionIdMarker` response parameters as a starting place in
    /// another request to return the rest of the results.
    pub is_truncated: bool,
    /// All of the keys rolled up into a common prefix count as a single return when calculating the number of returns.
    #[serde(default)]
    pub common_prefixes: Vec<CommonPrefix>,
    #[serde(default, rename = "Version")]
    pub versions: Vec<ObjectVersion>,
    /// Container for an object that is a delete marker.
    #[serde(default, rename = "DeleteMarker")]
    pub delete_markers: Vec<DeleteMarkerEntry>,
    pub name: String,
    pub prefix: String,
    pub max_keys: usize,
    #[serde(default)]
    pub delimiter: String,
    pub encoding_type: Option<String>,
    /// Marks the last key returned in a truncated response.
    #[serde(default)]
    pub key_marker: String,
    /// When the number of responses exceeds the value of `MaxKeys`,
    /// `NextKeyMarker` specifies the first key not returned that
    /// satisfies the search criteria. Use this value for the `key-marker`
    /// request parameter in a subsequent request.
    #[serde(default)]
    pub next_key_marker: String,
    /// Marks the last version of the key returned in a truncated response.
    #[serde(default)]
    pub version_id_marker: String,
    /// When the number of responses exceeds the value of `MaxKeys`,
    /// `NextVersionIdMarker` specifies the first object version not
    /// returned that satisfies the search criteria. Use this value
    /// for the `version-id-marker` request parameter in a subsequent request.
    #[serde(default)]
    pub next_version_id_marker: String,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct LocationConstraint {
    pub location_constraint: String,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Metrics {
    pub status: Status,
    pub event_threshold: Option<ReplicationTimeValue>,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct MultipartUpload {
    pub checksum_algorithm: String,
    pub upload_id: String,
    pub storage_class: String,
    pub key: String,
    pub initiated: String,
}

/// Specifies when noncurrent object versions expire.
#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct NoncurrentVersionExpiration {
    /// Specifies how many noncurrent versions Amazon S3 will retain.
    pub newer_noncurrent_versions: Option<i32>,
    /// Specifies the number of days an object is noncurrent before Amazon S3 can perform the associated action.
    pub noncurrent_days: Option<i32>,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct NoncurrentVersionTransition {
    /// Specifies how many noncurrent versions Amazon S3 will retain.
    pub newer_noncurrent_versions: Option<i32>,
    /// Specifies the number of days an object is noncurrent before Amazon S3 can perform the associated action.
    pub noncurrent_days: Option<i32>,
    pub storage_class: Option<StorageClass>,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Object {
    pub key: String,
    pub last_modified: String,
    pub e_tag: String,
    pub size: u64,
    pub storage_class: String,
    pub owner: Option<Owner>,
    pub checksum_algorithm: Option<String>,
}

/// The container element for an Object Lock rule.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "PascalCase")]
pub struct ObjectLockRule {
    pub default_retention: DefaultRetention,
}

/// Object representation of
/// - request XML of `put_object_lock_configuration` API
/// - response XML of `get_object_lock_configuration` API.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ObjectLockConfiguration {
    /// Indicates whether this bucket has an Object Lock configuration enabled.
    /// Enable ObjectLockEnabled when you apply ObjectLockConfiguration to a bucket.
    ///
    /// Valid Values: `Enabled`
    /// Required: No
    pub object_lock_enabled: String,
    pub rule: Option<ObjectLockRule>,
}

#[derive(Clone, Debug, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ObjectVersion {
    /// The object key.
    pub key: String,
    /// Date and time when the object was last modified.
    pub last_modified: String,
    /// Specifies whether the object is (true) or is not (false) the latest version of an object.
    pub is_latest: bool,
    /// The entity tag is an MD5 hash of that version of the object.
    pub e_tag: String,
    pub size: u64,
    pub storage_class: String,
    pub owner: Option<Owner>,
    /// Version ID of an object.
    pub version_id: Option<String>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Owner {
    pub display_name: String,
    #[serde(rename = "ID")]
    pub id: String,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Part {
    pub e_tag: String,
    pub part_number: usize,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Policy {
    version: String,
    id: String,
    statement: Vec<PolicyStatement>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct PolicyPrincipal {
    #[serde(rename = "AWS", default)]
    aws: Vec<String>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct PolicyStatement {
    sid: String,
    principal: PolicyPrincipal,
    effect: String,
    action: Vec<String>,
    resource: Vec<String>,
    condition: Option<String>,
}

#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct PolicyStatus {
    /// The policy status for this bucket.
    pub is_public: bool,
}

/// This data type contains information about progress of an operation.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Progress {
    pub bytes_processed: u64,
    pub bytes_returned: u64,
    pub bytes_scanned: u64,
}

/// PublicAccessBlockConfiguration parameters
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct PublicAccessBlockConfiguration {
    pub block_public_acls: bool,
    pub block_public_policy: bool,
    pub ignore_public_acls: bool,
    pub restrict_public_buckets: bool,
}

/// Specifies how requests are redirected.
/// In the event of an error, you can specify a different error code to return.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Redirect {
    pub host_name: Option<String>,
    pub http_redirect_code: Option<String>,
    pub protocol: Option<Protocol>,
    pub replace_key_prefix_with: Option<String>,
    pub replace_key_with: Option<String>,
}

/// Specifies the redirect behavior of all requests to a website endpoint of an Amazon S3 bucket.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct RedirectAllRequestsTo {
    pub host_name: String,
    pub protocol: Option<Protocol>,
}

/// ReplicationConfiguration parameters.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ReplicationConfiguration {
    pub role: Option<String>,
    #[serde(rename = "Rule", default)]
    pub rules: Vec<ReplicationRule>,
}

/// A filter that you can specify for selection for modifications on replicas.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ReplicaModifications {
    pub status: Status,
}

/// Specifies which Amazon S3 objects to replicate and where to store the replicas.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ReplicationRule {
    #[serde(rename = "ID", default)]
    pub id: Option<String>,
    pub prefix: Option<String>,
    pub priority: Option<i64>,
    pub delete_marker_replication: Option<DeleteMarkerReplication>,
    pub existing_object_replication: Option<ExistingObjectReplication>,
    /// Specifies whether the rule is enabled.
    pub status: Status,
    pub destination: Destination,
    pub source_selection_criteria: Option<SourceSelectionCriteria>,
    pub filter: Option<ReplicationRuleFilter>,
}

/// A container for specifying rule filters.
/// The filters determine the subset of objects to which the rule applies.
/// This element is required only if you specify more than one filter.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ReplicationRuleAndOperator {
    pub prefix: Option<String>,
    #[serde(rename = "tag")]
    pub tags: Option<Vec<Tag>>,
}

/// A filter that identifies the subset of objects to which the replication rule applies.
/// A Filter must specify exactly one Prefix, Tag, or an And child element.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ReplicationRuleFilter {
    pub prefix: Option<String>,
    pub tag: Option<Tag>,
    pub and: Option<ReplicationRuleAndOperator>,
}

/// A container specifying S3 Replication Time Control (S3 RTC) related information,
/// including whether S3 RTC is enabled and the time when all objects and operations on objects must be replicated.
/// Must be specified together with a Metrics block.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ReplicationTime {
    pub status: Status,
    pub time: ReplicationTimeValue,
}

/// A container specifying the time value for S3 Replication Time Control (S3 RTC) and replication metrics EventThreshold.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ReplicationTimeValue {
    pub minutes: Option<i32>,
}

/// Object representation of request XML of `put_object_retention` API
/// and response XML of `get_object_retention` API.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Retention {
    /// Valid Values: GOVERNANCE | COMPLIANCE
    pub mode: RetentionMode,
    /// The date on which this Object Lock Retention will expire.
    #[serde(deserialize_with = "crate::time::deserialize_with_str")]
    pub retain_until_date: UtcTime,
}

/// Specifies the redirect behavior and when a redirect is applied.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct RoutingRule {
    pub redirect: Redirect,
    pub condition: Option<Condition>,
}

/// Rules that define when a redirect is applied and the redirect behavior.
#[derive(Debug, Clone, Deserialize, Serialize, Default)]
#[serde(rename_all = "PascalCase")]
pub struct RoutingRules {
    pub routing_rule: Vec<RoutingRule>,
}

/// A container for filter information for the selection of S3 objects encrypted with AWS KMS.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct SseKmsEncryptedObjects {
    pub status: Status,
}

/// Specifies data related to access patterns to be collected and made available to analyze
/// the tradeoffs between different storage classes for an Amazon S3 bucket.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct StorageClassAnalysis {
    /// Specifies how data related to the storage class analysis for an Amazon S3 bucket should be exported.
    pub data_export: Option<StorageClassAnalysisDataExport>,
}

/// Container for data related to the storage class analysis for an Amazon S3 bucket for export.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct StorageClassAnalysisDataExport {
    /// The place to store the data for an analysis.
    pub destination: AnalyticsExportDestination,
    /// The version of the output schema to use when exporting data. Must be V_1.
    pub output_schema_version: String,
}

/// Describes the default server-side encryption to apply to new objects in the bucket.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ServerSideEncryptionByDefault {
    #[serde(rename = "SSEAlgorithm")]
    pub ssealgorithm: String,
    #[serde(rename = " KMSMasterKeyID")]
    pub kmsmaster_key_id: Option<String>,
}

/// Root level tag for the ServerSideEncryptionConfiguration parameters
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ServerSideEncryptionConfiguration {
    #[serde(rename = "Rule")]
    pub rules: Vec<ServerSideEncryptionRule>,
}

/// Specifies the default server-side encryption configuration.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct ServerSideEncryptionRule {
    pub apply_server_side_encryption_by_default: ServerSideEncryptionByDefault,
    #[serde(default)]
    pub bucket_key_enabled: bool,
}

/// A container that describes additional filters for identifying the source objects that you want to replicate.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct SourceSelectionCriteria {
    pub replica_modifications: Option<ReplicaModifications>,
    pub sse_kms_encrypted_objects: Option<SseKmsEncryptedObjects>,
}

/// Container for the stats details.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Stats {
    /// The total number of uncompressed object bytes processed.
    pub bytes_processed: u64,
    /// The total number of bytes of records payload data returned.
    pub bytes_returned: u64,
    /// The total number of object bytes scanned.
    pub bytes_scanned: u64,
}

/// A container of a key value name pair.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Tag {
    /// Name of the tag.
    pub key: String,
    /// Value of the tag.
    pub value: String,
}

/// A collection for a set of tags
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct TagSet {
    /// Array of [Tag]
    #[serde(rename = "Tag", default)]
    pub tags: Vec<Tag>,
}

/// Container for TagSet elements.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Tagging {
    /// A collection for a set of tags.
    pub tag_set: TagSet,
}

/// Specifies when an object transitions to a specified storage class.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct Transition {
    /// Indicates when objects are transitioned to the specified storage class.
    /// The date value must be in ISO 8601 format. The time is always midnight UTC.
    pub date: Option<String>,
    /// Indicates the number of days after creation when objects are transitioned to the specified storage class.
    pub days: Option<i32>,
    /// The storage class to which you want the object to transition.
    pub storage_class: Option<StorageClass>,
}

/// Describes the versioning state of an Amazon S3 bucket.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct VersioningConfiguration {
    /// Specifies whether MFA delete is enabled in the bucket versioning configuration.
    /// This element is only returned if the bucket has been configured with MFA delete.
    /// If the bucket has never been so configured, this element is not returned.
    ///
    /// Valid Values: Enabled | Disabled
    pub mfa_delete: Option<MFADelete>,

    /// The versioning state of the bucket.
    ///
    /// Valid Values: Enabled | Suspended
    pub status: Option<VersioningStatus>,
}

///  WebsiteConfiguration parameters.
#[derive(Debug, Clone, Deserialize, Serialize)]
#[serde(rename_all = "PascalCase")]
pub struct WebsiteConfiguration {
    pub error_document: Option<ErrorDocument>,
    pub index_document: IndexDocument,
    pub redirect_all_requests_to: Option<RedirectAllRequestsTo>,
    #[serde(default)]
    pub routing_rules: RoutingRules,
}

//////////////////  Enum Type

#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub enum ChecksumAlgorithm {
    CRC32,
    CRC32C,
    SHA1,
    SHA256,
}

/// Type of grantee
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub enum GranteeType {
    CanonicalUser,
    AmazonCustomerByEmail,
    Group,
}

#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub enum LegalHoldStatus {
    ON,
    OFF,
}

/// Specifies whether MFA delete is enabled in the bucket versioning configuration.
/// This element is only returned if the bucket has been configured with MFA delete.
/// If the bucket has never been so configured, this element is not returned.
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub enum MFADelete {
    Enabled,
    Disabled,
}

#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub enum Protocol {
    http,
    https,
}

/// Retention mode, Valid Values: `GOVERNANCE | COMPLIANCE`
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq, Default)]
pub enum RetentionMode {
    #[default]
    GOVERNANCE,
    COMPLIANCE,
}

/// The permission given to the grantee.. Valid Values: `FULL_CONTROL | WRITE | WRITE_ACP | READ | READ_ACP`
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub enum Permission {
    FULL_CONTROL,
    WRITE,
    WRITE_ACP,
    READ,
    READ_ACP,
}

/// Valid Values: `Enabled | Disabled`
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub enum Status {
    Enabled,
    Disabled,
}

/// The storage class to use when replicating objects, such as S3 Standard or reduced redundancy.
/// By default, Amazon S3 uses the storage class of the source object to create the object replica.
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub enum StorageClass {
    STANDARD,
    REDUCED_REDUNDANCY,
    STANDARD_IA,
    ONEZONE_IA,
    INTELLIGENT_TIERING,
    GLACIER,
    DEEP_ARCHIVE,
    OUTPOSTS,
    GLACIER_IR,
    SNOW,
    EXPRESS_ONEZONE,
}

/// The versioning state of the bucket.
#[derive(Debug, Clone, Deserialize, Serialize, PartialEq)]
pub enum VersioningStatus {
    Enabled,
    Suspended,
}