rustack_s3_model/
types.rs

1//! Auto-generated from AWS S3 Smithy model. DO NOT EDIT.
2
3use serde::{Deserialize, Serialize};
4
5/// S3 ArchiveStatus enum.
6#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
7pub enum ArchiveStatus {
8    /// Default variant.
9    #[default]
10    #[serde(rename = "ARCHIVE_ACCESS")]
11    ArchiveAccess,
12    #[serde(rename = "DEEP_ARCHIVE_ACCESS")]
13    DeepArchiveAccess,
14}
15
16impl ArchiveStatus {
17    /// Returns the string value of this enum variant.
18    #[must_use]
19    pub fn as_str(&self) -> &'static str {
20        match self {
21            Self::ArchiveAccess => "ARCHIVE_ACCESS",
22            Self::DeepArchiveAccess => "DEEP_ARCHIVE_ACCESS",
23        }
24    }
25}
26
27impl std::fmt::Display for ArchiveStatus {
28    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
29        f.write_str(self.as_str())
30    }
31}
32
33impl From<&str> for ArchiveStatus {
34    fn from(s: &str) -> Self {
35        match s {
36            "ARCHIVE_ACCESS" => Self::ArchiveAccess,
37            "DEEP_ARCHIVE_ACCESS" => Self::DeepArchiveAccess,
38            _ => Self::default(),
39        }
40    }
41}
42
43/// S3 BucketAccelerateStatus enum.
44#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
45pub enum BucketAccelerateStatus {
46    /// Default variant.
47    #[default]
48    Enabled,
49    Suspended,
50}
51
52impl BucketAccelerateStatus {
53    /// Returns the string value of this enum variant.
54    #[must_use]
55    pub fn as_str(&self) -> &'static str {
56        match self {
57            Self::Enabled => "Enabled",
58            Self::Suspended => "Suspended",
59        }
60    }
61}
62
63impl std::fmt::Display for BucketAccelerateStatus {
64    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
65        f.write_str(self.as_str())
66    }
67}
68
69impl From<&str> for BucketAccelerateStatus {
70    fn from(s: &str) -> Self {
71        match s {
72            "Enabled" => Self::Enabled,
73            "Suspended" => Self::Suspended,
74            _ => Self::default(),
75        }
76    }
77}
78
79/// S3 BucketCannedACL enum.
80#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
81pub enum BucketCannedACL {
82    /// Default variant.
83    #[default]
84    #[serde(rename = "authenticated-read")]
85    AuthenticatedRead,
86    #[serde(rename = "private")]
87    Private,
88    #[serde(rename = "public-read")]
89    PublicRead,
90    #[serde(rename = "public-read-write")]
91    PublicReadWrite,
92}
93
94impl BucketCannedACL {
95    /// Returns the string value of this enum variant.
96    #[must_use]
97    pub fn as_str(&self) -> &'static str {
98        match self {
99            Self::AuthenticatedRead => "authenticated-read",
100            Self::Private => "private",
101            Self::PublicRead => "public-read",
102            Self::PublicReadWrite => "public-read-write",
103        }
104    }
105}
106
107impl std::fmt::Display for BucketCannedACL {
108    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
109        f.write_str(self.as_str())
110    }
111}
112
113impl From<&str> for BucketCannedACL {
114    fn from(s: &str) -> Self {
115        match s {
116            "authenticated-read" => Self::AuthenticatedRead,
117            "private" => Self::Private,
118            "public-read" => Self::PublicRead,
119            "public-read-write" => Self::PublicReadWrite,
120            _ => Self::default(),
121        }
122    }
123}
124
125/// S3 BucketLocationConstraint enum.
126#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
127pub enum BucketLocationConstraint {
128    /// Default variant.
129    #[default]
130    #[serde(rename = "af-south-1")]
131    AfSouth1,
132    #[serde(rename = "ap-east-1")]
133    ApEast1,
134    #[serde(rename = "ap-northeast-1")]
135    ApNortheast1,
136    #[serde(rename = "ap-northeast-2")]
137    ApNortheast2,
138    #[serde(rename = "ap-northeast-3")]
139    ApNortheast3,
140    #[serde(rename = "ap-south-1")]
141    ApSouth1,
142    #[serde(rename = "ap-south-2")]
143    ApSouth2,
144    #[serde(rename = "ap-southeast-1")]
145    ApSoutheast1,
146    #[serde(rename = "ap-southeast-2")]
147    ApSoutheast2,
148    #[serde(rename = "ap-southeast-3")]
149    ApSoutheast3,
150    #[serde(rename = "ap-southeast-4")]
151    ApSoutheast4,
152    #[serde(rename = "ap-southeast-5")]
153    ApSoutheast5,
154    #[serde(rename = "ca-central-1")]
155    CaCentral1,
156    #[serde(rename = "cn-north-1")]
157    CnNorth1,
158    #[serde(rename = "cn-northwest-1")]
159    CnNorthwest1,
160    #[serde(rename = "EU")]
161    Eu,
162    #[serde(rename = "eu-central-1")]
163    EuCentral1,
164    #[serde(rename = "eu-central-2")]
165    EuCentral2,
166    #[serde(rename = "eu-north-1")]
167    EuNorth1,
168    #[serde(rename = "eu-south-1")]
169    EuSouth1,
170    #[serde(rename = "eu-south-2")]
171    EuSouth2,
172    #[serde(rename = "eu-west-1")]
173    EuWest1,
174    #[serde(rename = "eu-west-2")]
175    EuWest2,
176    #[serde(rename = "eu-west-3")]
177    EuWest3,
178    #[serde(rename = "il-central-1")]
179    IlCentral1,
180    #[serde(rename = "me-central-1")]
181    MeCentral1,
182    #[serde(rename = "me-south-1")]
183    MeSouth1,
184    #[serde(rename = "sa-east-1")]
185    SaEast1,
186    #[serde(rename = "us-east-2")]
187    UsEast2,
188    #[serde(rename = "us-gov-east-1")]
189    UsGovEast1,
190    #[serde(rename = "us-gov-west-1")]
191    UsGovWest1,
192    #[serde(rename = "us-west-1")]
193    UsWest1,
194    #[serde(rename = "us-west-2")]
195    UsWest2,
196}
197
198impl BucketLocationConstraint {
199    /// Returns the string value of this enum variant.
200    #[must_use]
201    pub fn as_str(&self) -> &'static str {
202        match self {
203            Self::AfSouth1 => "af-south-1",
204            Self::ApEast1 => "ap-east-1",
205            Self::ApNortheast1 => "ap-northeast-1",
206            Self::ApNortheast2 => "ap-northeast-2",
207            Self::ApNortheast3 => "ap-northeast-3",
208            Self::ApSouth1 => "ap-south-1",
209            Self::ApSouth2 => "ap-south-2",
210            Self::ApSoutheast1 => "ap-southeast-1",
211            Self::ApSoutheast2 => "ap-southeast-2",
212            Self::ApSoutheast3 => "ap-southeast-3",
213            Self::ApSoutheast4 => "ap-southeast-4",
214            Self::ApSoutheast5 => "ap-southeast-5",
215            Self::CaCentral1 => "ca-central-1",
216            Self::CnNorth1 => "cn-north-1",
217            Self::CnNorthwest1 => "cn-northwest-1",
218            Self::Eu => "EU",
219            Self::EuCentral1 => "eu-central-1",
220            Self::EuCentral2 => "eu-central-2",
221            Self::EuNorth1 => "eu-north-1",
222            Self::EuSouth1 => "eu-south-1",
223            Self::EuSouth2 => "eu-south-2",
224            Self::EuWest1 => "eu-west-1",
225            Self::EuWest2 => "eu-west-2",
226            Self::EuWest3 => "eu-west-3",
227            Self::IlCentral1 => "il-central-1",
228            Self::MeCentral1 => "me-central-1",
229            Self::MeSouth1 => "me-south-1",
230            Self::SaEast1 => "sa-east-1",
231            Self::UsEast2 => "us-east-2",
232            Self::UsGovEast1 => "us-gov-east-1",
233            Self::UsGovWest1 => "us-gov-west-1",
234            Self::UsWest1 => "us-west-1",
235            Self::UsWest2 => "us-west-2",
236        }
237    }
238}
239
240impl std::fmt::Display for BucketLocationConstraint {
241    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
242        f.write_str(self.as_str())
243    }
244}
245
246impl From<&str> for BucketLocationConstraint {
247    fn from(s: &str) -> Self {
248        match s {
249            "af-south-1" => Self::AfSouth1,
250            "ap-east-1" => Self::ApEast1,
251            "ap-northeast-1" => Self::ApNortheast1,
252            "ap-northeast-2" => Self::ApNortheast2,
253            "ap-northeast-3" => Self::ApNortheast3,
254            "ap-south-1" => Self::ApSouth1,
255            "ap-south-2" => Self::ApSouth2,
256            "ap-southeast-1" => Self::ApSoutheast1,
257            "ap-southeast-2" => Self::ApSoutheast2,
258            "ap-southeast-3" => Self::ApSoutheast3,
259            "ap-southeast-4" => Self::ApSoutheast4,
260            "ap-southeast-5" => Self::ApSoutheast5,
261            "ca-central-1" => Self::CaCentral1,
262            "cn-north-1" => Self::CnNorth1,
263            "cn-northwest-1" => Self::CnNorthwest1,
264            "EU" => Self::Eu,
265            "eu-central-1" => Self::EuCentral1,
266            "eu-central-2" => Self::EuCentral2,
267            "eu-north-1" => Self::EuNorth1,
268            "eu-south-1" => Self::EuSouth1,
269            "eu-south-2" => Self::EuSouth2,
270            "eu-west-1" => Self::EuWest1,
271            "eu-west-2" => Self::EuWest2,
272            "eu-west-3" => Self::EuWest3,
273            "il-central-1" => Self::IlCentral1,
274            "me-central-1" => Self::MeCentral1,
275            "me-south-1" => Self::MeSouth1,
276            "sa-east-1" => Self::SaEast1,
277            "us-east-2" => Self::UsEast2,
278            "us-gov-east-1" => Self::UsGovEast1,
279            "us-gov-west-1" => Self::UsGovWest1,
280            "us-west-1" => Self::UsWest1,
281            "us-west-2" => Self::UsWest2,
282            _ => Self::default(),
283        }
284    }
285}
286
287/// S3 BucketLogsPermission enum.
288#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
289pub enum BucketLogsPermission {
290    /// Default variant.
291    #[default]
292    #[serde(rename = "FULL_CONTROL")]
293    FullControl,
294    #[serde(rename = "READ")]
295    Read,
296    #[serde(rename = "WRITE")]
297    Write,
298}
299
300impl BucketLogsPermission {
301    /// Returns the string value of this enum variant.
302    #[must_use]
303    pub fn as_str(&self) -> &'static str {
304        match self {
305            Self::FullControl => "FULL_CONTROL",
306            Self::Read => "READ",
307            Self::Write => "WRITE",
308        }
309    }
310}
311
312impl std::fmt::Display for BucketLogsPermission {
313    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
314        f.write_str(self.as_str())
315    }
316}
317
318impl From<&str> for BucketLogsPermission {
319    fn from(s: &str) -> Self {
320        match s {
321            "FULL_CONTROL" => Self::FullControl,
322            "READ" => Self::Read,
323            "WRITE" => Self::Write,
324            _ => Self::default(),
325        }
326    }
327}
328
329/// S3 BucketType enum.
330#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
331pub enum BucketType {
332    /// Default variant.
333    #[default]
334    Directory,
335}
336
337impl BucketType {
338    /// Returns the string value of this enum variant.
339    #[must_use]
340    pub fn as_str(&self) -> &'static str {
341        match self {
342            Self::Directory => "Directory",
343        }
344    }
345}
346
347impl std::fmt::Display for BucketType {
348    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
349        f.write_str(self.as_str())
350    }
351}
352
353impl From<&str> for BucketType {
354    fn from(s: &str) -> Self {
355        match s {
356            "Directory" => Self::Directory,
357            _ => Self::default(),
358        }
359    }
360}
361
362/// S3 BucketVersioningStatus enum.
363#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
364pub enum BucketVersioningStatus {
365    /// Default variant.
366    #[default]
367    Enabled,
368    Suspended,
369}
370
371impl BucketVersioningStatus {
372    /// Returns the string value of this enum variant.
373    #[must_use]
374    pub fn as_str(&self) -> &'static str {
375        match self {
376            Self::Enabled => "Enabled",
377            Self::Suspended => "Suspended",
378        }
379    }
380}
381
382impl std::fmt::Display for BucketVersioningStatus {
383    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
384        f.write_str(self.as_str())
385    }
386}
387
388impl From<&str> for BucketVersioningStatus {
389    fn from(s: &str) -> Self {
390        match s {
391            "Enabled" => Self::Enabled,
392            "Suspended" => Self::Suspended,
393            _ => Self::default(),
394        }
395    }
396}
397
398/// S3 ChecksumAlgorithm enum.
399#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
400pub enum ChecksumAlgorithm {
401    /// Default variant.
402    #[default]
403    #[serde(rename = "CRC32")]
404    Crc32,
405    #[serde(rename = "CRC32C")]
406    Crc32c,
407    #[serde(rename = "CRC64NVME")]
408    Crc64nvme,
409    #[serde(rename = "SHA1")]
410    Sha1,
411    #[serde(rename = "SHA256")]
412    Sha256,
413}
414
415impl ChecksumAlgorithm {
416    /// Returns the string value of this enum variant.
417    #[must_use]
418    pub fn as_str(&self) -> &'static str {
419        match self {
420            Self::Crc32 => "CRC32",
421            Self::Crc32c => "CRC32C",
422            Self::Crc64nvme => "CRC64NVME",
423            Self::Sha1 => "SHA1",
424            Self::Sha256 => "SHA256",
425        }
426    }
427}
428
429impl std::fmt::Display for ChecksumAlgorithm {
430    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
431        f.write_str(self.as_str())
432    }
433}
434
435impl From<&str> for ChecksumAlgorithm {
436    fn from(s: &str) -> Self {
437        match s {
438            "CRC32" => Self::Crc32,
439            "CRC32C" => Self::Crc32c,
440            "CRC64NVME" => Self::Crc64nvme,
441            "SHA1" => Self::Sha1,
442            "SHA256" => Self::Sha256,
443            _ => Self::default(),
444        }
445    }
446}
447
448/// S3 ChecksumMode enum.
449#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
450pub enum ChecksumMode {
451    /// Default variant.
452    #[default]
453    #[serde(rename = "ENABLED")]
454    Enabled,
455}
456
457impl ChecksumMode {
458    /// Returns the string value of this enum variant.
459    #[must_use]
460    pub fn as_str(&self) -> &'static str {
461        match self {
462            Self::Enabled => "ENABLED",
463        }
464    }
465}
466
467impl std::fmt::Display for ChecksumMode {
468    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
469        f.write_str(self.as_str())
470    }
471}
472
473impl From<&str> for ChecksumMode {
474    fn from(s: &str) -> Self {
475        match s {
476            "ENABLED" => Self::Enabled,
477            _ => Self::default(),
478        }
479    }
480}
481
482/// S3 ChecksumType enum.
483#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
484pub enum ChecksumType {
485    /// Default variant.
486    #[default]
487    #[serde(rename = "COMPOSITE")]
488    Composite,
489    #[serde(rename = "FULL_OBJECT")]
490    FullObject,
491}
492
493impl ChecksumType {
494    /// Returns the string value of this enum variant.
495    #[must_use]
496    pub fn as_str(&self) -> &'static str {
497        match self {
498            Self::Composite => "COMPOSITE",
499            Self::FullObject => "FULL_OBJECT",
500        }
501    }
502}
503
504impl std::fmt::Display for ChecksumType {
505    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
506        f.write_str(self.as_str())
507    }
508}
509
510impl From<&str> for ChecksumType {
511    fn from(s: &str) -> Self {
512        match s {
513            "COMPOSITE" => Self::Composite,
514            "FULL_OBJECT" => Self::FullObject,
515            _ => Self::default(),
516        }
517    }
518}
519
520/// S3 DataRedundancy enum.
521#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
522pub enum DataRedundancy {
523    /// Default variant.
524    #[default]
525    SingleAvailabilityZone,
526    SingleLocalZone,
527}
528
529impl DataRedundancy {
530    /// Returns the string value of this enum variant.
531    #[must_use]
532    pub fn as_str(&self) -> &'static str {
533        match self {
534            Self::SingleAvailabilityZone => "SingleAvailabilityZone",
535            Self::SingleLocalZone => "SingleLocalZone",
536        }
537    }
538}
539
540impl std::fmt::Display for DataRedundancy {
541    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
542        f.write_str(self.as_str())
543    }
544}
545
546impl From<&str> for DataRedundancy {
547    fn from(s: &str) -> Self {
548        match s {
549            "SingleAvailabilityZone" => Self::SingleAvailabilityZone,
550            "SingleLocalZone" => Self::SingleLocalZone,
551            _ => Self::default(),
552        }
553    }
554}
555
556/// S3 EncodingType enum.
557#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
558pub enum EncodingType {
559    /// Default variant.
560    #[default]
561    #[serde(rename = "url")]
562    Url,
563}
564
565impl EncodingType {
566    /// Returns the string value of this enum variant.
567    #[must_use]
568    pub fn as_str(&self) -> &'static str {
569        match self {
570            Self::Url => "url",
571        }
572    }
573}
574
575impl std::fmt::Display for EncodingType {
576    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
577        f.write_str(self.as_str())
578    }
579}
580
581impl From<&str> for EncodingType {
582    fn from(s: &str) -> Self {
583        match s {
584            "url" => Self::Url,
585            _ => Self::default(),
586        }
587    }
588}
589
590/// S3 EncryptionType enum.
591#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
592pub enum EncryptionType {
593    /// Default variant.
594    #[default]
595    #[serde(rename = "NONE")]
596    None,
597    #[serde(rename = "SSE-C")]
598    SseC,
599}
600
601impl EncryptionType {
602    /// Returns the string value of this enum variant.
603    #[must_use]
604    pub fn as_str(&self) -> &'static str {
605        match self {
606            Self::None => "NONE",
607            Self::SseC => "SSE-C",
608        }
609    }
610}
611
612impl std::fmt::Display for EncryptionType {
613    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
614        f.write_str(self.as_str())
615    }
616}
617
618impl From<&str> for EncryptionType {
619    fn from(s: &str) -> Self {
620        match s {
621            "NONE" => Self::None,
622            "SSE-C" => Self::SseC,
623            _ => Self::default(),
624        }
625    }
626}
627
628/// S3 Event enum.
629#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
630pub enum Event {
631    /// Default variant.
632    #[default]
633    #[serde(rename = "s3:IntelligentTiering")]
634    S3IntelligentTiering,
635    #[serde(rename = "s3:LifecycleExpiration:*")]
636    S3LifecycleExpiration,
637    #[serde(rename = "s3:LifecycleExpiration:Delete")]
638    S3LifecycleExpirationDelete,
639    #[serde(rename = "s3:LifecycleExpiration:DeleteMarkerCreated")]
640    S3LifecycleExpirationDeleteMarkerCreated,
641    #[serde(rename = "s3:LifecycleTransition")]
642    S3LifecycleTransition,
643    #[serde(rename = "s3:ObjectAcl:Put")]
644    S3ObjectAclPut,
645    #[serde(rename = "s3:ObjectCreated:*")]
646    S3ObjectCreated,
647    #[serde(rename = "s3:ObjectCreated:CompleteMultipartUpload")]
648    S3ObjectCreatedCompleteMultipartUpload,
649    #[serde(rename = "s3:ObjectCreated:Copy")]
650    S3ObjectCreatedCopy,
651    #[serde(rename = "s3:ObjectCreated:Post")]
652    S3ObjectCreatedPost,
653    #[serde(rename = "s3:ObjectCreated:Put")]
654    S3ObjectCreatedPut,
655    #[serde(rename = "s3:ObjectRemoved:*")]
656    S3ObjectRemoved,
657    #[serde(rename = "s3:ObjectRemoved:Delete")]
658    S3ObjectRemovedDelete,
659    #[serde(rename = "s3:ObjectRemoved:DeleteMarkerCreated")]
660    S3ObjectRemovedDeleteMarkerCreated,
661    #[serde(rename = "s3:ObjectRestore:*")]
662    S3ObjectRestore,
663    #[serde(rename = "s3:ObjectRestore:Completed")]
664    S3ObjectRestoreCompleted,
665    #[serde(rename = "s3:ObjectRestore:Delete")]
666    S3ObjectRestoreDelete,
667    #[serde(rename = "s3:ObjectRestore:Post")]
668    S3ObjectRestorePost,
669    #[serde(rename = "s3:ObjectTagging:*")]
670    S3ObjectTagging,
671    #[serde(rename = "s3:ObjectTagging:Delete")]
672    S3ObjectTaggingDelete,
673    #[serde(rename = "s3:ObjectTagging:Put")]
674    S3ObjectTaggingPut,
675    #[serde(rename = "s3:ReducedRedundancyLostObject")]
676    S3ReducedRedundancyLostObject,
677    #[serde(rename = "s3:Replication:*")]
678    S3Replication,
679    #[serde(rename = "s3:Replication:OperationFailedReplication")]
680    S3ReplicationOperationFailedReplication,
681    #[serde(rename = "s3:Replication:OperationMissedThreshold")]
682    S3ReplicationOperationMissedThreshold,
683    #[serde(rename = "s3:Replication:OperationNotTracked")]
684    S3ReplicationOperationNotTracked,
685    #[serde(rename = "s3:Replication:OperationReplicatedAfterThreshold")]
686    S3ReplicationOperationReplicatedAfterThreshold,
687}
688
689impl Event {
690    /// Returns the string value of this enum variant.
691    #[must_use]
692    pub fn as_str(&self) -> &'static str {
693        match self {
694            Self::S3IntelligentTiering => "s3:IntelligentTiering",
695            Self::S3LifecycleExpiration => "s3:LifecycleExpiration:*",
696            Self::S3LifecycleExpirationDelete => "s3:LifecycleExpiration:Delete",
697            Self::S3LifecycleExpirationDeleteMarkerCreated => {
698                "s3:LifecycleExpiration:DeleteMarkerCreated"
699            }
700            Self::S3LifecycleTransition => "s3:LifecycleTransition",
701            Self::S3ObjectAclPut => "s3:ObjectAcl:Put",
702            Self::S3ObjectCreated => "s3:ObjectCreated:*",
703            Self::S3ObjectCreatedCompleteMultipartUpload => {
704                "s3:ObjectCreated:CompleteMultipartUpload"
705            }
706            Self::S3ObjectCreatedCopy => "s3:ObjectCreated:Copy",
707            Self::S3ObjectCreatedPost => "s3:ObjectCreated:Post",
708            Self::S3ObjectCreatedPut => "s3:ObjectCreated:Put",
709            Self::S3ObjectRemoved => "s3:ObjectRemoved:*",
710            Self::S3ObjectRemovedDelete => "s3:ObjectRemoved:Delete",
711            Self::S3ObjectRemovedDeleteMarkerCreated => "s3:ObjectRemoved:DeleteMarkerCreated",
712            Self::S3ObjectRestore => "s3:ObjectRestore:*",
713            Self::S3ObjectRestoreCompleted => "s3:ObjectRestore:Completed",
714            Self::S3ObjectRestoreDelete => "s3:ObjectRestore:Delete",
715            Self::S3ObjectRestorePost => "s3:ObjectRestore:Post",
716            Self::S3ObjectTagging => "s3:ObjectTagging:*",
717            Self::S3ObjectTaggingDelete => "s3:ObjectTagging:Delete",
718            Self::S3ObjectTaggingPut => "s3:ObjectTagging:Put",
719            Self::S3ReducedRedundancyLostObject => "s3:ReducedRedundancyLostObject",
720            Self::S3Replication => "s3:Replication:*",
721            Self::S3ReplicationOperationFailedReplication => {
722                "s3:Replication:OperationFailedReplication"
723            }
724            Self::S3ReplicationOperationMissedThreshold => {
725                "s3:Replication:OperationMissedThreshold"
726            }
727            Self::S3ReplicationOperationNotTracked => "s3:Replication:OperationNotTracked",
728            Self::S3ReplicationOperationReplicatedAfterThreshold => {
729                "s3:Replication:OperationReplicatedAfterThreshold"
730            }
731        }
732    }
733}
734
735impl std::fmt::Display for Event {
736    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
737        f.write_str(self.as_str())
738    }
739}
740
741impl From<&str> for Event {
742    fn from(s: &str) -> Self {
743        match s {
744            "s3:IntelligentTiering" => Self::S3IntelligentTiering,
745            "s3:LifecycleExpiration:*" => Self::S3LifecycleExpiration,
746            "s3:LifecycleExpiration:Delete" => Self::S3LifecycleExpirationDelete,
747            "s3:LifecycleExpiration:DeleteMarkerCreated" => {
748                Self::S3LifecycleExpirationDeleteMarkerCreated
749            }
750            "s3:LifecycleTransition" => Self::S3LifecycleTransition,
751            "s3:ObjectAcl:Put" => Self::S3ObjectAclPut,
752            "s3:ObjectCreated:*" => Self::S3ObjectCreated,
753            "s3:ObjectCreated:CompleteMultipartUpload" => {
754                Self::S3ObjectCreatedCompleteMultipartUpload
755            }
756            "s3:ObjectCreated:Copy" => Self::S3ObjectCreatedCopy,
757            "s3:ObjectCreated:Post" => Self::S3ObjectCreatedPost,
758            "s3:ObjectCreated:Put" => Self::S3ObjectCreatedPut,
759            "s3:ObjectRemoved:*" => Self::S3ObjectRemoved,
760            "s3:ObjectRemoved:Delete" => Self::S3ObjectRemovedDelete,
761            "s3:ObjectRemoved:DeleteMarkerCreated" => Self::S3ObjectRemovedDeleteMarkerCreated,
762            "s3:ObjectRestore:*" => Self::S3ObjectRestore,
763            "s3:ObjectRestore:Completed" => Self::S3ObjectRestoreCompleted,
764            "s3:ObjectRestore:Delete" => Self::S3ObjectRestoreDelete,
765            "s3:ObjectRestore:Post" => Self::S3ObjectRestorePost,
766            "s3:ObjectTagging:*" => Self::S3ObjectTagging,
767            "s3:ObjectTagging:Delete" => Self::S3ObjectTaggingDelete,
768            "s3:ObjectTagging:Put" => Self::S3ObjectTaggingPut,
769            "s3:ReducedRedundancyLostObject" => Self::S3ReducedRedundancyLostObject,
770            "s3:Replication:*" => Self::S3Replication,
771            "s3:Replication:OperationFailedReplication" => {
772                Self::S3ReplicationOperationFailedReplication
773            }
774            "s3:Replication:OperationMissedThreshold" => {
775                Self::S3ReplicationOperationMissedThreshold
776            }
777            "s3:Replication:OperationNotTracked" => Self::S3ReplicationOperationNotTracked,
778            "s3:Replication:OperationReplicatedAfterThreshold" => {
779                Self::S3ReplicationOperationReplicatedAfterThreshold
780            }
781            _ => Self::default(),
782        }
783    }
784}
785
786/// S3 ExpirationStatus enum.
787#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
788pub enum ExpirationStatus {
789    /// Default variant.
790    #[default]
791    Disabled,
792    Enabled,
793}
794
795impl ExpirationStatus {
796    /// Returns the string value of this enum variant.
797    #[must_use]
798    pub fn as_str(&self) -> &'static str {
799        match self {
800            Self::Disabled => "Disabled",
801            Self::Enabled => "Enabled",
802        }
803    }
804}
805
806impl std::fmt::Display for ExpirationStatus {
807    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
808        f.write_str(self.as_str())
809    }
810}
811
812impl From<&str> for ExpirationStatus {
813    fn from(s: &str) -> Self {
814        match s {
815            "Disabled" => Self::Disabled,
816            "Enabled" => Self::Enabled,
817            _ => Self::default(),
818        }
819    }
820}
821
822/// S3 FilterRuleName enum.
823#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
824pub enum FilterRuleName {
825    /// Default variant.
826    #[default]
827    #[serde(rename = "prefix")]
828    Prefix,
829    #[serde(rename = "suffix")]
830    Suffix,
831}
832
833impl FilterRuleName {
834    /// Returns the string value of this enum variant.
835    #[must_use]
836    pub fn as_str(&self) -> &'static str {
837        match self {
838            Self::Prefix => "prefix",
839            Self::Suffix => "suffix",
840        }
841    }
842}
843
844impl std::fmt::Display for FilterRuleName {
845    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
846        f.write_str(self.as_str())
847    }
848}
849
850impl From<&str> for FilterRuleName {
851    fn from(s: &str) -> Self {
852        match s {
853            "prefix" => Self::Prefix,
854            "suffix" => Self::Suffix,
855            _ => Self::default(),
856        }
857    }
858}
859
860/// S3 LocationType enum.
861#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
862pub enum LocationType {
863    /// Default variant.
864    #[default]
865    AvailabilityZone,
866    LocalZone,
867}
868
869impl LocationType {
870    /// Returns the string value of this enum variant.
871    #[must_use]
872    pub fn as_str(&self) -> &'static str {
873        match self {
874            Self::AvailabilityZone => "AvailabilityZone",
875            Self::LocalZone => "LocalZone",
876        }
877    }
878}
879
880impl std::fmt::Display for LocationType {
881    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
882        f.write_str(self.as_str())
883    }
884}
885
886impl From<&str> for LocationType {
887    fn from(s: &str) -> Self {
888        match s {
889            "AvailabilityZone" => Self::AvailabilityZone,
890            "LocalZone" => Self::LocalZone,
891            _ => Self::default(),
892        }
893    }
894}
895
896/// S3 MFADelete enum.
897#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
898pub enum MFADelete {
899    /// Default variant.
900    #[default]
901    Disabled,
902    Enabled,
903}
904
905impl MFADelete {
906    /// Returns the string value of this enum variant.
907    #[must_use]
908    pub fn as_str(&self) -> &'static str {
909        match self {
910            Self::Disabled => "Disabled",
911            Self::Enabled => "Enabled",
912        }
913    }
914}
915
916impl std::fmt::Display for MFADelete {
917    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
918        f.write_str(self.as_str())
919    }
920}
921
922impl From<&str> for MFADelete {
923    fn from(s: &str) -> Self {
924        match s {
925            "Disabled" => Self::Disabled,
926            "Enabled" => Self::Enabled,
927            _ => Self::default(),
928        }
929    }
930}
931
932/// S3 MFADeleteStatus enum.
933#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
934pub enum MFADeleteStatus {
935    /// Default variant.
936    #[default]
937    Disabled,
938    Enabled,
939}
940
941impl MFADeleteStatus {
942    /// Returns the string value of this enum variant.
943    #[must_use]
944    pub fn as_str(&self) -> &'static str {
945        match self {
946            Self::Disabled => "Disabled",
947            Self::Enabled => "Enabled",
948        }
949    }
950}
951
952impl std::fmt::Display for MFADeleteStatus {
953    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
954        f.write_str(self.as_str())
955    }
956}
957
958impl From<&str> for MFADeleteStatus {
959    fn from(s: &str) -> Self {
960        match s {
961            "Disabled" => Self::Disabled,
962            "Enabled" => Self::Enabled,
963            _ => Self::default(),
964        }
965    }
966}
967
968/// S3 MetadataDirective enum.
969#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
970pub enum MetadataDirective {
971    /// Default variant.
972    #[default]
973    #[serde(rename = "COPY")]
974    Copy,
975    #[serde(rename = "REPLACE")]
976    Replace,
977}
978
979impl MetadataDirective {
980    /// Returns the string value of this enum variant.
981    #[must_use]
982    pub fn as_str(&self) -> &'static str {
983        match self {
984            Self::Copy => "COPY",
985            Self::Replace => "REPLACE",
986        }
987    }
988}
989
990impl std::fmt::Display for MetadataDirective {
991    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
992        f.write_str(self.as_str())
993    }
994}
995
996impl From<&str> for MetadataDirective {
997    fn from(s: &str) -> Self {
998        match s {
999            "COPY" => Self::Copy,
1000            "REPLACE" => Self::Replace,
1001            _ => Self::default(),
1002        }
1003    }
1004}
1005
1006/// S3 ObjectAttributes enum.
1007#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1008pub enum ObjectAttributes {
1009    /// Default variant.
1010    #[default]
1011    Checksum,
1012    #[serde(rename = "ETag")]
1013    Etag,
1014    ObjectParts,
1015    ObjectSize,
1016    StorageClass,
1017}
1018
1019impl ObjectAttributes {
1020    /// Returns the string value of this enum variant.
1021    #[must_use]
1022    pub fn as_str(&self) -> &'static str {
1023        match self {
1024            Self::Checksum => "Checksum",
1025            Self::Etag => "ETag",
1026            Self::ObjectParts => "ObjectParts",
1027            Self::ObjectSize => "ObjectSize",
1028            Self::StorageClass => "StorageClass",
1029        }
1030    }
1031}
1032
1033impl std::fmt::Display for ObjectAttributes {
1034    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1035        f.write_str(self.as_str())
1036    }
1037}
1038
1039impl From<&str> for ObjectAttributes {
1040    fn from(s: &str) -> Self {
1041        match s {
1042            "Checksum" => Self::Checksum,
1043            "ETag" => Self::Etag,
1044            "ObjectParts" => Self::ObjectParts,
1045            "ObjectSize" => Self::ObjectSize,
1046            "StorageClass" => Self::StorageClass,
1047            _ => Self::default(),
1048        }
1049    }
1050}
1051
1052/// S3 ObjectCannedACL enum.
1053#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1054pub enum ObjectCannedACL {
1055    /// Default variant.
1056    #[default]
1057    #[serde(rename = "authenticated-read")]
1058    AuthenticatedRead,
1059    #[serde(rename = "aws-exec-read")]
1060    AwsExecRead,
1061    #[serde(rename = "bucket-owner-full-control")]
1062    BucketOwnerFullControl,
1063    #[serde(rename = "bucket-owner-read")]
1064    BucketOwnerRead,
1065    #[serde(rename = "private")]
1066    Private,
1067    #[serde(rename = "public-read")]
1068    PublicRead,
1069    #[serde(rename = "public-read-write")]
1070    PublicReadWrite,
1071}
1072
1073impl ObjectCannedACL {
1074    /// Returns the string value of this enum variant.
1075    #[must_use]
1076    pub fn as_str(&self) -> &'static str {
1077        match self {
1078            Self::AuthenticatedRead => "authenticated-read",
1079            Self::AwsExecRead => "aws-exec-read",
1080            Self::BucketOwnerFullControl => "bucket-owner-full-control",
1081            Self::BucketOwnerRead => "bucket-owner-read",
1082            Self::Private => "private",
1083            Self::PublicRead => "public-read",
1084            Self::PublicReadWrite => "public-read-write",
1085        }
1086    }
1087}
1088
1089impl std::fmt::Display for ObjectCannedACL {
1090    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1091        f.write_str(self.as_str())
1092    }
1093}
1094
1095impl From<&str> for ObjectCannedACL {
1096    fn from(s: &str) -> Self {
1097        match s {
1098            "authenticated-read" => Self::AuthenticatedRead,
1099            "aws-exec-read" => Self::AwsExecRead,
1100            "bucket-owner-full-control" => Self::BucketOwnerFullControl,
1101            "bucket-owner-read" => Self::BucketOwnerRead,
1102            "private" => Self::Private,
1103            "public-read" => Self::PublicRead,
1104            "public-read-write" => Self::PublicReadWrite,
1105            _ => Self::default(),
1106        }
1107    }
1108}
1109
1110/// S3 ObjectLockEnabled enum.
1111#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1112pub enum ObjectLockEnabled {
1113    /// Default variant.
1114    #[default]
1115    Enabled,
1116}
1117
1118impl ObjectLockEnabled {
1119    /// Returns the string value of this enum variant.
1120    #[must_use]
1121    pub fn as_str(&self) -> &'static str {
1122        match self {
1123            Self::Enabled => "Enabled",
1124        }
1125    }
1126}
1127
1128impl std::fmt::Display for ObjectLockEnabled {
1129    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1130        f.write_str(self.as_str())
1131    }
1132}
1133
1134impl From<&str> for ObjectLockEnabled {
1135    fn from(s: &str) -> Self {
1136        match s {
1137            "Enabled" => Self::Enabled,
1138            _ => Self::default(),
1139        }
1140    }
1141}
1142
1143/// S3 ObjectLockLegalHoldStatus enum.
1144#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1145pub enum ObjectLockLegalHoldStatus {
1146    /// Default variant.
1147    #[default]
1148    #[serde(rename = "OFF")]
1149    Off,
1150    #[serde(rename = "ON")]
1151    On,
1152}
1153
1154impl ObjectLockLegalHoldStatus {
1155    /// Returns the string value of this enum variant.
1156    #[must_use]
1157    pub fn as_str(&self) -> &'static str {
1158        match self {
1159            Self::Off => "OFF",
1160            Self::On => "ON",
1161        }
1162    }
1163}
1164
1165impl std::fmt::Display for ObjectLockLegalHoldStatus {
1166    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1167        f.write_str(self.as_str())
1168    }
1169}
1170
1171impl From<&str> for ObjectLockLegalHoldStatus {
1172    fn from(s: &str) -> Self {
1173        match s {
1174            "OFF" => Self::Off,
1175            "ON" => Self::On,
1176            _ => Self::default(),
1177        }
1178    }
1179}
1180
1181/// S3 ObjectLockMode enum.
1182#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1183pub enum ObjectLockMode {
1184    /// Default variant.
1185    #[default]
1186    #[serde(rename = "COMPLIANCE")]
1187    Compliance,
1188    #[serde(rename = "GOVERNANCE")]
1189    Governance,
1190}
1191
1192impl ObjectLockMode {
1193    /// Returns the string value of this enum variant.
1194    #[must_use]
1195    pub fn as_str(&self) -> &'static str {
1196        match self {
1197            Self::Compliance => "COMPLIANCE",
1198            Self::Governance => "GOVERNANCE",
1199        }
1200    }
1201}
1202
1203impl std::fmt::Display for ObjectLockMode {
1204    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1205        f.write_str(self.as_str())
1206    }
1207}
1208
1209impl From<&str> for ObjectLockMode {
1210    fn from(s: &str) -> Self {
1211        match s {
1212            "COMPLIANCE" => Self::Compliance,
1213            "GOVERNANCE" => Self::Governance,
1214            _ => Self::default(),
1215        }
1216    }
1217}
1218
1219/// S3 ObjectLockRetentionMode enum.
1220#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1221pub enum ObjectLockRetentionMode {
1222    /// Default variant.
1223    #[default]
1224    #[serde(rename = "COMPLIANCE")]
1225    Compliance,
1226    #[serde(rename = "GOVERNANCE")]
1227    Governance,
1228}
1229
1230impl ObjectLockRetentionMode {
1231    /// Returns the string value of this enum variant.
1232    #[must_use]
1233    pub fn as_str(&self) -> &'static str {
1234        match self {
1235            Self::Compliance => "COMPLIANCE",
1236            Self::Governance => "GOVERNANCE",
1237        }
1238    }
1239}
1240
1241impl std::fmt::Display for ObjectLockRetentionMode {
1242    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1243        f.write_str(self.as_str())
1244    }
1245}
1246
1247impl From<&str> for ObjectLockRetentionMode {
1248    fn from(s: &str) -> Self {
1249        match s {
1250            "COMPLIANCE" => Self::Compliance,
1251            "GOVERNANCE" => Self::Governance,
1252            _ => Self::default(),
1253        }
1254    }
1255}
1256
1257/// S3 ObjectOwnership enum.
1258#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1259pub enum ObjectOwnership {
1260    /// Default variant.
1261    #[default]
1262    BucketOwnerEnforced,
1263    BucketOwnerPreferred,
1264    ObjectWriter,
1265}
1266
1267impl ObjectOwnership {
1268    /// Returns the string value of this enum variant.
1269    #[must_use]
1270    pub fn as_str(&self) -> &'static str {
1271        match self {
1272            Self::BucketOwnerEnforced => "BucketOwnerEnforced",
1273            Self::BucketOwnerPreferred => "BucketOwnerPreferred",
1274            Self::ObjectWriter => "ObjectWriter",
1275        }
1276    }
1277}
1278
1279impl std::fmt::Display for ObjectOwnership {
1280    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1281        f.write_str(self.as_str())
1282    }
1283}
1284
1285impl From<&str> for ObjectOwnership {
1286    fn from(s: &str) -> Self {
1287        match s {
1288            "BucketOwnerEnforced" => Self::BucketOwnerEnforced,
1289            "BucketOwnerPreferred" => Self::BucketOwnerPreferred,
1290            "ObjectWriter" => Self::ObjectWriter,
1291            _ => Self::default(),
1292        }
1293    }
1294}
1295
1296/// S3 ObjectStorageClass enum.
1297#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1298pub enum ObjectStorageClass {
1299    /// Default variant.
1300    #[default]
1301    #[serde(rename = "DEEP_ARCHIVE")]
1302    DeepArchive,
1303    #[serde(rename = "EXPRESS_ONEZONE")]
1304    ExpressOnezone,
1305    #[serde(rename = "FSX_ONTAP")]
1306    FsxOntap,
1307    #[serde(rename = "FSX_OPENZFS")]
1308    FsxOpenzfs,
1309    #[serde(rename = "GLACIER")]
1310    Glacier,
1311    #[serde(rename = "GLACIER_IR")]
1312    GlacierIr,
1313    #[serde(rename = "INTELLIGENT_TIERING")]
1314    IntelligentTiering,
1315    #[serde(rename = "ONEZONE_IA")]
1316    OnezoneIa,
1317    #[serde(rename = "OUTPOSTS")]
1318    Outposts,
1319    #[serde(rename = "REDUCED_REDUNDANCY")]
1320    ReducedRedundancy,
1321    #[serde(rename = "SNOW")]
1322    Snow,
1323    #[serde(rename = "STANDARD")]
1324    Standard,
1325    #[serde(rename = "STANDARD_IA")]
1326    StandardIa,
1327}
1328
1329impl ObjectStorageClass {
1330    /// Returns the string value of this enum variant.
1331    #[must_use]
1332    pub fn as_str(&self) -> &'static str {
1333        match self {
1334            Self::DeepArchive => "DEEP_ARCHIVE",
1335            Self::ExpressOnezone => "EXPRESS_ONEZONE",
1336            Self::FsxOntap => "FSX_ONTAP",
1337            Self::FsxOpenzfs => "FSX_OPENZFS",
1338            Self::Glacier => "GLACIER",
1339            Self::GlacierIr => "GLACIER_IR",
1340            Self::IntelligentTiering => "INTELLIGENT_TIERING",
1341            Self::OnezoneIa => "ONEZONE_IA",
1342            Self::Outposts => "OUTPOSTS",
1343            Self::ReducedRedundancy => "REDUCED_REDUNDANCY",
1344            Self::Snow => "SNOW",
1345            Self::Standard => "STANDARD",
1346            Self::StandardIa => "STANDARD_IA",
1347        }
1348    }
1349}
1350
1351impl std::fmt::Display for ObjectStorageClass {
1352    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1353        f.write_str(self.as_str())
1354    }
1355}
1356
1357impl From<&str> for ObjectStorageClass {
1358    fn from(s: &str) -> Self {
1359        match s {
1360            "DEEP_ARCHIVE" => Self::DeepArchive,
1361            "EXPRESS_ONEZONE" => Self::ExpressOnezone,
1362            "FSX_ONTAP" => Self::FsxOntap,
1363            "FSX_OPENZFS" => Self::FsxOpenzfs,
1364            "GLACIER" => Self::Glacier,
1365            "GLACIER_IR" => Self::GlacierIr,
1366            "INTELLIGENT_TIERING" => Self::IntelligentTiering,
1367            "ONEZONE_IA" => Self::OnezoneIa,
1368            "OUTPOSTS" => Self::Outposts,
1369            "REDUCED_REDUNDANCY" => Self::ReducedRedundancy,
1370            "SNOW" => Self::Snow,
1371            "STANDARD" => Self::Standard,
1372            "STANDARD_IA" => Self::StandardIa,
1373            _ => Self::default(),
1374        }
1375    }
1376}
1377
1378/// S3 ObjectVersionStorageClass enum.
1379#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1380pub enum ObjectVersionStorageClass {
1381    /// Default variant.
1382    #[default]
1383    #[serde(rename = "STANDARD")]
1384    Standard,
1385}
1386
1387impl ObjectVersionStorageClass {
1388    /// Returns the string value of this enum variant.
1389    #[must_use]
1390    pub fn as_str(&self) -> &'static str {
1391        match self {
1392            Self::Standard => "STANDARD",
1393        }
1394    }
1395}
1396
1397impl std::fmt::Display for ObjectVersionStorageClass {
1398    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1399        f.write_str(self.as_str())
1400    }
1401}
1402
1403impl From<&str> for ObjectVersionStorageClass {
1404    fn from(s: &str) -> Self {
1405        match s {
1406            "STANDARD" => Self::Standard,
1407            _ => Self::default(),
1408        }
1409    }
1410}
1411
1412/// S3 OptionalObjectAttributes enum.
1413#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1414pub enum OptionalObjectAttributes {
1415    /// Default variant.
1416    #[default]
1417    RestoreStatus,
1418}
1419
1420impl OptionalObjectAttributes {
1421    /// Returns the string value of this enum variant.
1422    #[must_use]
1423    pub fn as_str(&self) -> &'static str {
1424        match self {
1425            Self::RestoreStatus => "RestoreStatus",
1426        }
1427    }
1428}
1429
1430impl std::fmt::Display for OptionalObjectAttributes {
1431    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1432        f.write_str(self.as_str())
1433    }
1434}
1435
1436impl From<&str> for OptionalObjectAttributes {
1437    fn from(s: &str) -> Self {
1438        match s {
1439            "RestoreStatus" => Self::RestoreStatus,
1440            _ => Self::default(),
1441        }
1442    }
1443}
1444
1445/// S3 PartitionDateSource enum.
1446#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1447pub enum PartitionDateSource {
1448    /// Default variant.
1449    #[default]
1450    DeliveryTime,
1451    EventTime,
1452}
1453
1454impl PartitionDateSource {
1455    /// Returns the string value of this enum variant.
1456    #[must_use]
1457    pub fn as_str(&self) -> &'static str {
1458        match self {
1459            Self::DeliveryTime => "DeliveryTime",
1460            Self::EventTime => "EventTime",
1461        }
1462    }
1463}
1464
1465impl std::fmt::Display for PartitionDateSource {
1466    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1467        f.write_str(self.as_str())
1468    }
1469}
1470
1471impl From<&str> for PartitionDateSource {
1472    fn from(s: &str) -> Self {
1473        match s {
1474            "DeliveryTime" => Self::DeliveryTime,
1475            "EventTime" => Self::EventTime,
1476            _ => Self::default(),
1477        }
1478    }
1479}
1480
1481/// S3 Payer enum.
1482#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1483pub enum Payer {
1484    /// Default variant.
1485    #[default]
1486    BucketOwner,
1487    Requester,
1488}
1489
1490impl Payer {
1491    /// Returns the string value of this enum variant.
1492    #[must_use]
1493    pub fn as_str(&self) -> &'static str {
1494        match self {
1495            Self::BucketOwner => "BucketOwner",
1496            Self::Requester => "Requester",
1497        }
1498    }
1499}
1500
1501impl std::fmt::Display for Payer {
1502    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1503        f.write_str(self.as_str())
1504    }
1505}
1506
1507impl From<&str> for Payer {
1508    fn from(s: &str) -> Self {
1509        match s {
1510            "BucketOwner" => Self::BucketOwner,
1511            "Requester" => Self::Requester,
1512            _ => Self::default(),
1513        }
1514    }
1515}
1516
1517/// S3 Permission enum.
1518#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1519pub enum Permission {
1520    /// Default variant.
1521    #[default]
1522    #[serde(rename = "FULL_CONTROL")]
1523    FullControl,
1524    #[serde(rename = "READ")]
1525    Read,
1526    #[serde(rename = "READ_ACP")]
1527    ReadAcp,
1528    #[serde(rename = "WRITE")]
1529    Write,
1530    #[serde(rename = "WRITE_ACP")]
1531    WriteAcp,
1532}
1533
1534impl Permission {
1535    /// Returns the string value of this enum variant.
1536    #[must_use]
1537    pub fn as_str(&self) -> &'static str {
1538        match self {
1539            Self::FullControl => "FULL_CONTROL",
1540            Self::Read => "READ",
1541            Self::ReadAcp => "READ_ACP",
1542            Self::Write => "WRITE",
1543            Self::WriteAcp => "WRITE_ACP",
1544        }
1545    }
1546}
1547
1548impl std::fmt::Display for Permission {
1549    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1550        f.write_str(self.as_str())
1551    }
1552}
1553
1554impl From<&str> for Permission {
1555    fn from(s: &str) -> Self {
1556        match s {
1557            "FULL_CONTROL" => Self::FullControl,
1558            "READ" => Self::Read,
1559            "READ_ACP" => Self::ReadAcp,
1560            "WRITE" => Self::Write,
1561            "WRITE_ACP" => Self::WriteAcp,
1562            _ => Self::default(),
1563        }
1564    }
1565}
1566
1567/// S3 Protocol enum.
1568#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1569pub enum Protocol {
1570    /// Default variant.
1571    #[default]
1572    #[serde(rename = "http")]
1573    Http,
1574    #[serde(rename = "https")]
1575    Https,
1576}
1577
1578impl Protocol {
1579    /// Returns the string value of this enum variant.
1580    #[must_use]
1581    pub fn as_str(&self) -> &'static str {
1582        match self {
1583            Self::Http => "http",
1584            Self::Https => "https",
1585        }
1586    }
1587}
1588
1589impl std::fmt::Display for Protocol {
1590    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1591        f.write_str(self.as_str())
1592    }
1593}
1594
1595impl From<&str> for Protocol {
1596    fn from(s: &str) -> Self {
1597        match s {
1598            "http" => Self::Http,
1599            "https" => Self::Https,
1600            _ => Self::default(),
1601        }
1602    }
1603}
1604
1605/// S3 ReplicationStatus enum.
1606#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1607pub enum ReplicationStatus {
1608    /// Default variant.
1609    #[default]
1610    #[serde(rename = "COMPLETE")]
1611    Complete,
1612    #[serde(rename = "COMPLETED")]
1613    Completed,
1614    #[serde(rename = "FAILED")]
1615    Failed,
1616    #[serde(rename = "PENDING")]
1617    Pending,
1618    #[serde(rename = "REPLICA")]
1619    Replica,
1620}
1621
1622impl ReplicationStatus {
1623    /// Returns the string value of this enum variant.
1624    #[must_use]
1625    pub fn as_str(&self) -> &'static str {
1626        match self {
1627            Self::Complete => "COMPLETE",
1628            Self::Completed => "COMPLETED",
1629            Self::Failed => "FAILED",
1630            Self::Pending => "PENDING",
1631            Self::Replica => "REPLICA",
1632        }
1633    }
1634}
1635
1636impl std::fmt::Display for ReplicationStatus {
1637    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1638        f.write_str(self.as_str())
1639    }
1640}
1641
1642impl From<&str> for ReplicationStatus {
1643    fn from(s: &str) -> Self {
1644        match s {
1645            "COMPLETE" => Self::Complete,
1646            "COMPLETED" => Self::Completed,
1647            "FAILED" => Self::Failed,
1648            "PENDING" => Self::Pending,
1649            "REPLICA" => Self::Replica,
1650            _ => Self::default(),
1651        }
1652    }
1653}
1654
1655/// S3 RequestCharged enum.
1656#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1657pub enum RequestCharged {
1658    /// Default variant.
1659    #[default]
1660    #[serde(rename = "requester")]
1661    Requester,
1662}
1663
1664impl RequestCharged {
1665    /// Returns the string value of this enum variant.
1666    #[must_use]
1667    pub fn as_str(&self) -> &'static str {
1668        match self {
1669            Self::Requester => "requester",
1670        }
1671    }
1672}
1673
1674impl std::fmt::Display for RequestCharged {
1675    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1676        f.write_str(self.as_str())
1677    }
1678}
1679
1680impl From<&str> for RequestCharged {
1681    fn from(s: &str) -> Self {
1682        match s {
1683            "requester" => Self::Requester,
1684            _ => Self::default(),
1685        }
1686    }
1687}
1688
1689/// S3 RequestPayer enum.
1690#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1691pub enum RequestPayer {
1692    /// Default variant.
1693    #[default]
1694    #[serde(rename = "requester")]
1695    Requester,
1696}
1697
1698impl RequestPayer {
1699    /// Returns the string value of this enum variant.
1700    #[must_use]
1701    pub fn as_str(&self) -> &'static str {
1702        match self {
1703            Self::Requester => "requester",
1704        }
1705    }
1706}
1707
1708impl std::fmt::Display for RequestPayer {
1709    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1710        f.write_str(self.as_str())
1711    }
1712}
1713
1714impl From<&str> for RequestPayer {
1715    fn from(s: &str) -> Self {
1716        match s {
1717            "requester" => Self::Requester,
1718            _ => Self::default(),
1719        }
1720    }
1721}
1722
1723/// S3 ServerSideEncryption enum.
1724#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1725pub enum ServerSideEncryption {
1726    /// Default variant.
1727    #[default]
1728    #[serde(rename = "AES256")]
1729    Aes256,
1730    #[serde(rename = "aws:fsx")]
1731    AwsFsx,
1732    #[serde(rename = "aws:kms")]
1733    AwsKms,
1734    #[serde(rename = "aws:kms:dsse")]
1735    AwsKmsDsse,
1736}
1737
1738impl ServerSideEncryption {
1739    /// Returns the string value of this enum variant.
1740    #[must_use]
1741    pub fn as_str(&self) -> &'static str {
1742        match self {
1743            Self::Aes256 => "AES256",
1744            Self::AwsFsx => "aws:fsx",
1745            Self::AwsKms => "aws:kms",
1746            Self::AwsKmsDsse => "aws:kms:dsse",
1747        }
1748    }
1749}
1750
1751impl std::fmt::Display for ServerSideEncryption {
1752    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1753        f.write_str(self.as_str())
1754    }
1755}
1756
1757impl From<&str> for ServerSideEncryption {
1758    fn from(s: &str) -> Self {
1759        match s {
1760            "AES256" => Self::Aes256,
1761            "aws:fsx" => Self::AwsFsx,
1762            "aws:kms" => Self::AwsKms,
1763            "aws:kms:dsse" => Self::AwsKmsDsse,
1764            _ => Self::default(),
1765        }
1766    }
1767}
1768
1769/// S3 StorageClass enum.
1770#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1771pub enum StorageClass {
1772    /// Default variant.
1773    #[default]
1774    #[serde(rename = "DEEP_ARCHIVE")]
1775    DeepArchive,
1776    #[serde(rename = "EXPRESS_ONEZONE")]
1777    ExpressOnezone,
1778    #[serde(rename = "FSX_ONTAP")]
1779    FsxOntap,
1780    #[serde(rename = "FSX_OPENZFS")]
1781    FsxOpenzfs,
1782    #[serde(rename = "GLACIER")]
1783    Glacier,
1784    #[serde(rename = "GLACIER_IR")]
1785    GlacierIr,
1786    #[serde(rename = "INTELLIGENT_TIERING")]
1787    IntelligentTiering,
1788    #[serde(rename = "ONEZONE_IA")]
1789    OnezoneIa,
1790    #[serde(rename = "OUTPOSTS")]
1791    Outposts,
1792    #[serde(rename = "REDUCED_REDUNDANCY")]
1793    ReducedRedundancy,
1794    #[serde(rename = "SNOW")]
1795    Snow,
1796    #[serde(rename = "STANDARD")]
1797    Standard,
1798    #[serde(rename = "STANDARD_IA")]
1799    StandardIa,
1800}
1801
1802impl StorageClass {
1803    /// Returns the string value of this enum variant.
1804    #[must_use]
1805    pub fn as_str(&self) -> &'static str {
1806        match self {
1807            Self::DeepArchive => "DEEP_ARCHIVE",
1808            Self::ExpressOnezone => "EXPRESS_ONEZONE",
1809            Self::FsxOntap => "FSX_ONTAP",
1810            Self::FsxOpenzfs => "FSX_OPENZFS",
1811            Self::Glacier => "GLACIER",
1812            Self::GlacierIr => "GLACIER_IR",
1813            Self::IntelligentTiering => "INTELLIGENT_TIERING",
1814            Self::OnezoneIa => "ONEZONE_IA",
1815            Self::Outposts => "OUTPOSTS",
1816            Self::ReducedRedundancy => "REDUCED_REDUNDANCY",
1817            Self::Snow => "SNOW",
1818            Self::Standard => "STANDARD",
1819            Self::StandardIa => "STANDARD_IA",
1820        }
1821    }
1822}
1823
1824impl std::fmt::Display for StorageClass {
1825    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1826        f.write_str(self.as_str())
1827    }
1828}
1829
1830impl From<&str> for StorageClass {
1831    fn from(s: &str) -> Self {
1832        match s {
1833            "DEEP_ARCHIVE" => Self::DeepArchive,
1834            "EXPRESS_ONEZONE" => Self::ExpressOnezone,
1835            "FSX_ONTAP" => Self::FsxOntap,
1836            "FSX_OPENZFS" => Self::FsxOpenzfs,
1837            "GLACIER" => Self::Glacier,
1838            "GLACIER_IR" => Self::GlacierIr,
1839            "INTELLIGENT_TIERING" => Self::IntelligentTiering,
1840            "ONEZONE_IA" => Self::OnezoneIa,
1841            "OUTPOSTS" => Self::Outposts,
1842            "REDUCED_REDUNDANCY" => Self::ReducedRedundancy,
1843            "SNOW" => Self::Snow,
1844            "STANDARD" => Self::Standard,
1845            "STANDARD_IA" => Self::StandardIa,
1846            _ => Self::default(),
1847        }
1848    }
1849}
1850
1851/// S3 TaggingDirective enum.
1852#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1853pub enum TaggingDirective {
1854    /// Default variant.
1855    #[default]
1856    #[serde(rename = "COPY")]
1857    Copy,
1858    #[serde(rename = "REPLACE")]
1859    Replace,
1860}
1861
1862impl TaggingDirective {
1863    /// Returns the string value of this enum variant.
1864    #[must_use]
1865    pub fn as_str(&self) -> &'static str {
1866        match self {
1867            Self::Copy => "COPY",
1868            Self::Replace => "REPLACE",
1869        }
1870    }
1871}
1872
1873impl std::fmt::Display for TaggingDirective {
1874    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1875        f.write_str(self.as_str())
1876    }
1877}
1878
1879impl From<&str> for TaggingDirective {
1880    fn from(s: &str) -> Self {
1881        match s {
1882            "COPY" => Self::Copy,
1883            "REPLACE" => Self::Replace,
1884            _ => Self::default(),
1885        }
1886    }
1887}
1888
1889/// S3 TransitionDefaultMinimumObjectSize enum.
1890#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1891pub enum TransitionDefaultMinimumObjectSize {
1892    /// Default variant.
1893    #[default]
1894    #[serde(rename = "all_storage_classes_128K")]
1895    AllStorageClasses128k,
1896    #[serde(rename = "varies_by_storage_class")]
1897    VariesByStorageClass,
1898}
1899
1900impl TransitionDefaultMinimumObjectSize {
1901    /// Returns the string value of this enum variant.
1902    #[must_use]
1903    pub fn as_str(&self) -> &'static str {
1904        match self {
1905            Self::AllStorageClasses128k => "all_storage_classes_128K",
1906            Self::VariesByStorageClass => "varies_by_storage_class",
1907        }
1908    }
1909}
1910
1911impl std::fmt::Display for TransitionDefaultMinimumObjectSize {
1912    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1913        f.write_str(self.as_str())
1914    }
1915}
1916
1917impl From<&str> for TransitionDefaultMinimumObjectSize {
1918    fn from(s: &str) -> Self {
1919        match s {
1920            "all_storage_classes_128K" => Self::AllStorageClasses128k,
1921            "varies_by_storage_class" => Self::VariesByStorageClass,
1922            _ => Self::default(),
1923        }
1924    }
1925}
1926
1927/// S3 TransitionStorageClass enum.
1928#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1929pub enum TransitionStorageClass {
1930    /// Default variant.
1931    #[default]
1932    #[serde(rename = "DEEP_ARCHIVE")]
1933    DeepArchive,
1934    #[serde(rename = "GLACIER")]
1935    Glacier,
1936    #[serde(rename = "GLACIER_IR")]
1937    GlacierIr,
1938    #[serde(rename = "INTELLIGENT_TIERING")]
1939    IntelligentTiering,
1940    #[serde(rename = "ONEZONE_IA")]
1941    OnezoneIa,
1942    #[serde(rename = "STANDARD_IA")]
1943    StandardIa,
1944}
1945
1946impl TransitionStorageClass {
1947    /// Returns the string value of this enum variant.
1948    #[must_use]
1949    pub fn as_str(&self) -> &'static str {
1950        match self {
1951            Self::DeepArchive => "DEEP_ARCHIVE",
1952            Self::Glacier => "GLACIER",
1953            Self::GlacierIr => "GLACIER_IR",
1954            Self::IntelligentTiering => "INTELLIGENT_TIERING",
1955            Self::OnezoneIa => "ONEZONE_IA",
1956            Self::StandardIa => "STANDARD_IA",
1957        }
1958    }
1959}
1960
1961impl std::fmt::Display for TransitionStorageClass {
1962    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1963        f.write_str(self.as_str())
1964    }
1965}
1966
1967impl From<&str> for TransitionStorageClass {
1968    fn from(s: &str) -> Self {
1969        match s {
1970            "DEEP_ARCHIVE" => Self::DeepArchive,
1971            "GLACIER" => Self::Glacier,
1972            "GLACIER_IR" => Self::GlacierIr,
1973            "INTELLIGENT_TIERING" => Self::IntelligentTiering,
1974            "ONEZONE_IA" => Self::OnezoneIa,
1975            "STANDARD_IA" => Self::StandardIa,
1976            _ => Self::default(),
1977        }
1978    }
1979}
1980
1981/// S3 Type enum.
1982#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
1983pub enum Type {
1984    /// Default variant.
1985    #[default]
1986    AmazonCustomerByEmail,
1987    CanonicalUser,
1988    Group,
1989}
1990
1991impl Type {
1992    /// Returns the string value of this enum variant.
1993    #[must_use]
1994    pub fn as_str(&self) -> &'static str {
1995        match self {
1996            Self::AmazonCustomerByEmail => "AmazonCustomerByEmail",
1997            Self::CanonicalUser => "CanonicalUser",
1998            Self::Group => "Group",
1999        }
2000    }
2001}
2002
2003impl std::fmt::Display for Type {
2004    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2005        f.write_str(self.as_str())
2006    }
2007}
2008
2009impl From<&str> for Type {
2010    fn from(s: &str) -> Self {
2011        match s {
2012            "AmazonCustomerByEmail" => Self::AmazonCustomerByEmail,
2013            "CanonicalUser" => Self::CanonicalUser,
2014            "Group" => Self::Group,
2015            _ => Self::default(),
2016        }
2017    }
2018}
2019
2020/// S3 AbortIncompleteMultipartUpload.
2021#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2022pub struct AbortIncompleteMultipartUpload {
2023    pub days_after_initiation: Option<i32>,
2024}
2025
2026/// S3 AccelerateConfiguration.
2027#[derive(Debug, Clone, Default)]
2028pub struct AccelerateConfiguration {
2029    pub status: Option<BucketAccelerateStatus>,
2030}
2031
2032/// S3 AccessControlPolicy.
2033#[derive(Debug, Clone, Default)]
2034pub struct AccessControlPolicy {
2035    pub grants: Vec<Grant>,
2036    pub owner: Option<Owner>,
2037}
2038
2039/// S3 BlockedEncryptionTypes.
2040#[derive(Debug, Clone, Default)]
2041pub struct BlockedEncryptionTypes {
2042    pub encryption_type: Vec<EncryptionType>,
2043}
2044
2045/// S3 Bucket.
2046#[derive(Debug, Clone, Default)]
2047pub struct Bucket {
2048    pub bucket_arn: Option<String>,
2049    pub bucket_region: Option<String>,
2050    pub creation_date: Option<chrono::DateTime<chrono::Utc>>,
2051    pub name: Option<String>,
2052}
2053
2054/// S3 BucketInfo.
2055#[derive(Debug, Clone, Default)]
2056pub struct BucketInfo {
2057    pub data_redundancy: Option<DataRedundancy>,
2058    pub r#type: Option<BucketType>,
2059}
2060
2061/// S3 BucketLifecycleConfiguration.
2062#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2063pub struct BucketLifecycleConfiguration {
2064    pub rules: Vec<LifecycleRule>,
2065}
2066
2067/// S3 BucketLoggingStatus.
2068#[derive(Debug, Clone, Default)]
2069pub struct BucketLoggingStatus {
2070    pub logging_enabled: Option<LoggingEnabled>,
2071}
2072
2073/// S3 CORSConfiguration.
2074#[derive(Debug, Clone, Default)]
2075pub struct CORSConfiguration {
2076    pub cors_rules: Vec<CORSRule>,
2077}
2078
2079/// S3 CORSRule.
2080#[derive(Debug, Clone, Default)]
2081pub struct CORSRule {
2082    pub allowed_headers: Vec<String>,
2083    pub allowed_methods: Vec<String>,
2084    pub allowed_origins: Vec<String>,
2085    pub expose_headers: Vec<String>,
2086    pub id: Option<String>,
2087    pub max_age_seconds: Option<i32>,
2088}
2089
2090/// S3 Checksum.
2091#[derive(Debug, Clone, Default)]
2092pub struct Checksum {
2093    pub checksum_crc32: Option<String>,
2094    pub checksum_crc32c: Option<String>,
2095    pub checksum_crc64nvme: Option<String>,
2096    pub checksum_sha1: Option<String>,
2097    pub checksum_sha256: Option<String>,
2098    pub checksum_type: Option<ChecksumType>,
2099}
2100
2101/// S3 CommonPrefix.
2102#[derive(Debug, Clone, Default)]
2103pub struct CommonPrefix {
2104    pub prefix: Option<String>,
2105}
2106
2107/// S3 CompletedMultipartUpload.
2108#[derive(Debug, Clone, Default)]
2109pub struct CompletedMultipartUpload {
2110    pub parts: Vec<CompletedPart>,
2111}
2112
2113/// S3 CompletedPart.
2114#[derive(Debug, Clone, Default)]
2115pub struct CompletedPart {
2116    pub checksum_crc32: Option<String>,
2117    pub checksum_crc32c: Option<String>,
2118    pub checksum_crc64nvme: Option<String>,
2119    pub checksum_sha1: Option<String>,
2120    pub checksum_sha256: Option<String>,
2121    pub e_tag: Option<String>,
2122    pub part_number: Option<i32>,
2123}
2124
2125/// S3 Condition.
2126#[derive(Debug, Clone, Default)]
2127pub struct Condition {
2128    pub http_error_code_returned_equals: Option<String>,
2129    pub key_prefix_equals: Option<String>,
2130}
2131
2132/// S3 CopyObjectResult.
2133#[derive(Debug, Clone, Default)]
2134pub struct CopyObjectResult {
2135    pub checksum_crc32: Option<String>,
2136    pub checksum_crc32c: Option<String>,
2137    pub checksum_crc64nvme: Option<String>,
2138    pub checksum_sha1: Option<String>,
2139    pub checksum_sha256: Option<String>,
2140    pub checksum_type: Option<ChecksumType>,
2141    pub e_tag: Option<String>,
2142    pub last_modified: Option<chrono::DateTime<chrono::Utc>>,
2143}
2144
2145/// S3 CopyPartResult.
2146#[derive(Debug, Clone, Default)]
2147pub struct CopyPartResult {
2148    pub checksum_crc32: Option<String>,
2149    pub checksum_crc32c: Option<String>,
2150    pub checksum_crc64nvme: Option<String>,
2151    pub checksum_sha1: Option<String>,
2152    pub checksum_sha256: Option<String>,
2153    pub e_tag: Option<String>,
2154    pub last_modified: Option<chrono::DateTime<chrono::Utc>>,
2155}
2156
2157/// S3 CreateBucketConfiguration.
2158#[derive(Debug, Clone, Default)]
2159pub struct CreateBucketConfiguration {
2160    pub bucket: Option<BucketInfo>,
2161    pub location: Option<LocationInfo>,
2162    pub location_constraint: Option<BucketLocationConstraint>,
2163    pub tags: Vec<Tag>,
2164}
2165
2166/// S3 DefaultRetention.
2167#[derive(Debug, Clone, Default)]
2168pub struct DefaultRetention {
2169    pub days: Option<i32>,
2170    pub mode: Option<ObjectLockRetentionMode>,
2171    pub years: Option<i32>,
2172}
2173
2174/// S3 Delete.
2175#[derive(Debug, Clone, Default)]
2176pub struct Delete {
2177    pub objects: Vec<ObjectIdentifier>,
2178    pub quiet: Option<bool>,
2179}
2180
2181/// S3 DeleteMarkerEntry.
2182#[derive(Debug, Clone, Default)]
2183pub struct DeleteMarkerEntry {
2184    pub is_latest: Option<bool>,
2185    pub key: Option<String>,
2186    pub last_modified: Option<chrono::DateTime<chrono::Utc>>,
2187    pub owner: Option<Owner>,
2188    pub version_id: Option<String>,
2189}
2190
2191/// S3 DeletedObject.
2192#[derive(Debug, Clone, Default)]
2193pub struct DeletedObject {
2194    pub delete_marker: Option<bool>,
2195    pub delete_marker_version_id: Option<String>,
2196    pub key: Option<String>,
2197    pub version_id: Option<String>,
2198}
2199
2200/// S3 Error.
2201#[derive(Debug, Clone, Default)]
2202pub struct Error {
2203    pub code: Option<String>,
2204    pub key: Option<String>,
2205    pub message: Option<String>,
2206    pub version_id: Option<String>,
2207}
2208
2209/// S3 ErrorDocument.
2210#[derive(Debug, Clone, Default)]
2211pub struct ErrorDocument {
2212    pub key: String,
2213}
2214
2215/// S3 EventBridgeConfiguration.
2216#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2217pub struct EventBridgeConfiguration {}
2218
2219/// S3 FilterRule.
2220#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2221pub struct FilterRule {
2222    pub name: Option<FilterRuleName>,
2223    pub value: Option<String>,
2224}
2225
2226/// S3 GetObjectAttributesParts.
2227#[derive(Debug, Clone, Default)]
2228pub struct GetObjectAttributesParts {
2229    pub is_truncated: Option<bool>,
2230    pub max_parts: Option<i32>,
2231    pub next_part_number_marker: Option<String>,
2232    pub part_number_marker: Option<String>,
2233    pub parts: Vec<ObjectPart>,
2234    pub total_parts_count: Option<i32>,
2235}
2236
2237/// S3 Grant.
2238#[derive(Debug, Clone, Default)]
2239pub struct Grant {
2240    pub grantee: Option<Grantee>,
2241    pub permission: Option<Permission>,
2242}
2243
2244/// S3 Grantee.
2245#[derive(Debug, Clone, Default)]
2246pub struct Grantee {
2247    pub display_name: Option<String>,
2248    pub email_address: Option<String>,
2249    pub id: Option<String>,
2250    pub r#type: Type,
2251    pub uri: Option<String>,
2252}
2253
2254/// S3 IndexDocument.
2255#[derive(Debug, Clone, Default)]
2256pub struct IndexDocument {
2257    pub suffix: String,
2258}
2259
2260/// S3 Initiator.
2261#[derive(Debug, Clone, Default)]
2262pub struct Initiator {
2263    pub display_name: Option<String>,
2264    pub id: Option<String>,
2265}
2266
2267/// S3 LambdaFunctionConfiguration.
2268#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2269pub struct LambdaFunctionConfiguration {
2270    pub events: Vec<Event>,
2271    pub filter: Option<NotificationConfigurationFilter>,
2272    pub id: Option<String>,
2273    pub lambda_function_arn: String,
2274}
2275
2276/// S3 LifecycleExpiration.
2277#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2278pub struct LifecycleExpiration {
2279    pub date: Option<chrono::DateTime<chrono::Utc>>,
2280    pub days: Option<i32>,
2281    pub expired_object_delete_marker: Option<bool>,
2282}
2283
2284/// S3 LifecycleRule.
2285#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2286pub struct LifecycleRule {
2287    pub abort_incomplete_multipart_upload: Option<AbortIncompleteMultipartUpload>,
2288    pub expiration: Option<LifecycleExpiration>,
2289    pub filter: Option<LifecycleRuleFilter>,
2290    pub id: Option<String>,
2291    pub noncurrent_version_expiration: Option<NoncurrentVersionExpiration>,
2292    pub noncurrent_version_transitions: Vec<NoncurrentVersionTransition>,
2293    pub prefix: Option<String>,
2294    pub status: ExpirationStatus,
2295    pub transitions: Vec<Transition>,
2296}
2297
2298/// S3 LifecycleRuleAndOperator.
2299#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2300pub struct LifecycleRuleAndOperator {
2301    pub object_size_greater_than: Option<i64>,
2302    pub object_size_less_than: Option<i64>,
2303    pub prefix: Option<String>,
2304    pub tags: Vec<Tag>,
2305}
2306
2307/// S3 LifecycleRuleFilter.
2308#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2309pub struct LifecycleRuleFilter {
2310    pub and: Option<LifecycleRuleAndOperator>,
2311    pub object_size_greater_than: Option<i64>,
2312    pub object_size_less_than: Option<i64>,
2313    pub prefix: Option<String>,
2314    pub tag: Option<Tag>,
2315}
2316
2317/// S3 LocationInfo.
2318#[derive(Debug, Clone, Default)]
2319pub struct LocationInfo {
2320    pub name: Option<String>,
2321    pub r#type: Option<LocationType>,
2322}
2323
2324/// S3 LoggingEnabled.
2325#[derive(Debug, Clone, Default)]
2326pub struct LoggingEnabled {
2327    pub target_bucket: String,
2328    pub target_grants: Vec<TargetGrant>,
2329    pub target_object_key_format: Option<TargetObjectKeyFormat>,
2330    pub target_prefix: String,
2331}
2332
2333/// S3 MultipartUpload.
2334#[derive(Debug, Clone, Default)]
2335pub struct MultipartUpload {
2336    pub checksum_algorithm: Option<ChecksumAlgorithm>,
2337    pub checksum_type: Option<ChecksumType>,
2338    pub initiated: Option<chrono::DateTime<chrono::Utc>>,
2339    pub initiator: Option<Initiator>,
2340    pub key: Option<String>,
2341    pub owner: Option<Owner>,
2342    pub storage_class: Option<StorageClass>,
2343    pub upload_id: Option<String>,
2344}
2345
2346/// S3 NoncurrentVersionExpiration.
2347#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2348pub struct NoncurrentVersionExpiration {
2349    pub newer_noncurrent_versions: Option<i32>,
2350    pub noncurrent_days: Option<i32>,
2351}
2352
2353/// S3 NoncurrentVersionTransition.
2354#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2355pub struct NoncurrentVersionTransition {
2356    pub newer_noncurrent_versions: Option<i32>,
2357    pub noncurrent_days: Option<i32>,
2358    pub storage_class: Option<TransitionStorageClass>,
2359}
2360
2361/// S3 NotificationConfiguration.
2362#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2363pub struct NotificationConfiguration {
2364    pub event_bridge_configuration: Option<EventBridgeConfiguration>,
2365    pub lambda_function_configurations: Vec<LambdaFunctionConfiguration>,
2366    pub queue_configurations: Vec<QueueConfiguration>,
2367    pub topic_configurations: Vec<TopicConfiguration>,
2368}
2369
2370/// S3 NotificationConfigurationFilter.
2371#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2372pub struct NotificationConfigurationFilter {
2373    pub key: Option<S3KeyFilter>,
2374}
2375
2376/// S3 Object.
2377#[derive(Debug, Clone, Default)]
2378pub struct Object {
2379    pub checksum_algorithm: Vec<ChecksumAlgorithm>,
2380    pub checksum_type: Option<ChecksumType>,
2381    pub e_tag: Option<String>,
2382    pub key: Option<String>,
2383    pub last_modified: Option<chrono::DateTime<chrono::Utc>>,
2384    pub owner: Option<Owner>,
2385    pub restore_status: Option<RestoreStatus>,
2386    pub size: Option<i64>,
2387    pub storage_class: Option<ObjectStorageClass>,
2388}
2389
2390/// S3 ObjectIdentifier.
2391#[derive(Debug, Clone, Default)]
2392pub struct ObjectIdentifier {
2393    pub e_tag: Option<String>,
2394    pub key: String,
2395    pub last_modified_time: Option<chrono::DateTime<chrono::Utc>>,
2396    pub size: Option<i64>,
2397    pub version_id: Option<String>,
2398}
2399
2400/// S3 ObjectLockConfiguration.
2401#[derive(Debug, Clone, Default)]
2402pub struct ObjectLockConfiguration {
2403    pub object_lock_enabled: Option<ObjectLockEnabled>,
2404    pub rule: Option<ObjectLockRule>,
2405}
2406
2407/// S3 ObjectLockLegalHold.
2408#[derive(Debug, Clone, Default)]
2409pub struct ObjectLockLegalHold {
2410    pub status: Option<ObjectLockLegalHoldStatus>,
2411}
2412
2413/// S3 ObjectLockRetention.
2414#[derive(Debug, Clone, Default)]
2415pub struct ObjectLockRetention {
2416    pub mode: Option<ObjectLockRetentionMode>,
2417    pub retain_until_date: Option<chrono::DateTime<chrono::Utc>>,
2418}
2419
2420/// S3 ObjectLockRule.
2421#[derive(Debug, Clone, Default)]
2422pub struct ObjectLockRule {
2423    pub default_retention: Option<DefaultRetention>,
2424}
2425
2426/// S3 ObjectPart.
2427#[derive(Debug, Clone, Default)]
2428pub struct ObjectPart {
2429    pub checksum_crc32: Option<String>,
2430    pub checksum_crc32c: Option<String>,
2431    pub checksum_crc64nvme: Option<String>,
2432    pub checksum_sha1: Option<String>,
2433    pub checksum_sha256: Option<String>,
2434    pub part_number: Option<i32>,
2435    pub size: Option<i64>,
2436}
2437
2438/// S3 ObjectVersion.
2439#[derive(Debug, Clone, Default)]
2440pub struct ObjectVersion {
2441    pub checksum_algorithm: Vec<ChecksumAlgorithm>,
2442    pub checksum_type: Option<ChecksumType>,
2443    pub e_tag: Option<String>,
2444    pub is_latest: Option<bool>,
2445    pub key: Option<String>,
2446    pub last_modified: Option<chrono::DateTime<chrono::Utc>>,
2447    pub owner: Option<Owner>,
2448    pub restore_status: Option<RestoreStatus>,
2449    pub size: Option<i64>,
2450    pub storage_class: Option<ObjectVersionStorageClass>,
2451    pub version_id: Option<String>,
2452}
2453
2454/// S3 Owner.
2455#[derive(Debug, Clone, Default)]
2456pub struct Owner {
2457    pub display_name: Option<String>,
2458    pub id: Option<String>,
2459}
2460
2461/// S3 OwnershipControls.
2462#[derive(Debug, Clone, Default)]
2463pub struct OwnershipControls {
2464    pub rules: Vec<OwnershipControlsRule>,
2465}
2466
2467/// S3 OwnershipControlsRule.
2468#[derive(Debug, Clone, Default)]
2469pub struct OwnershipControlsRule {
2470    pub object_ownership: ObjectOwnership,
2471}
2472
2473/// S3 Part.
2474#[derive(Debug, Clone, Default)]
2475pub struct Part {
2476    pub checksum_crc32: Option<String>,
2477    pub checksum_crc32c: Option<String>,
2478    pub checksum_crc64nvme: Option<String>,
2479    pub checksum_sha1: Option<String>,
2480    pub checksum_sha256: Option<String>,
2481    pub e_tag: Option<String>,
2482    pub last_modified: Option<chrono::DateTime<chrono::Utc>>,
2483    pub part_number: Option<i32>,
2484    pub size: Option<i64>,
2485}
2486
2487/// S3 PartitionedPrefix.
2488#[derive(Debug, Clone, Default)]
2489pub struct PartitionedPrefix {
2490    pub partition_date_source: Option<PartitionDateSource>,
2491}
2492
2493/// S3 PolicyStatus.
2494#[derive(Debug, Clone, Default)]
2495pub struct PolicyStatus {
2496    pub is_public: Option<bool>,
2497}
2498
2499/// S3 PublicAccessBlockConfiguration.
2500#[derive(Debug, Clone, Default)]
2501pub struct PublicAccessBlockConfiguration {
2502    pub block_public_acls: Option<bool>,
2503    pub block_public_policy: Option<bool>,
2504    pub ignore_public_acls: Option<bool>,
2505    pub restrict_public_buckets: Option<bool>,
2506}
2507
2508/// S3 QueueConfiguration.
2509#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2510pub struct QueueConfiguration {
2511    pub events: Vec<Event>,
2512    pub filter: Option<NotificationConfigurationFilter>,
2513    pub id: Option<String>,
2514    pub queue_arn: String,
2515}
2516
2517/// S3 Redirect.
2518#[derive(Debug, Clone, Default)]
2519pub struct Redirect {
2520    pub host_name: Option<String>,
2521    pub http_redirect_code: Option<String>,
2522    pub protocol: Option<Protocol>,
2523    pub replace_key_prefix_with: Option<String>,
2524    pub replace_key_with: Option<String>,
2525}
2526
2527/// S3 RedirectAllRequestsTo.
2528#[derive(Debug, Clone, Default)]
2529pub struct RedirectAllRequestsTo {
2530    pub host_name: String,
2531    pub protocol: Option<Protocol>,
2532}
2533
2534/// S3 RequestPaymentConfiguration.
2535#[derive(Debug, Clone, Default)]
2536pub struct RequestPaymentConfiguration {
2537    pub payer: Payer,
2538}
2539
2540/// S3 RestoreStatus.
2541#[derive(Debug, Clone, Default)]
2542pub struct RestoreStatus {
2543    pub is_restore_in_progress: Option<bool>,
2544    pub restore_expiry_date: Option<chrono::DateTime<chrono::Utc>>,
2545}
2546
2547/// S3 RoutingRule.
2548#[derive(Debug, Clone, Default)]
2549pub struct RoutingRule {
2550    pub condition: Option<Condition>,
2551    pub redirect: Redirect,
2552}
2553
2554/// S3 S3KeyFilter.
2555#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2556pub struct S3KeyFilter {
2557    pub filter_rules: Vec<FilterRule>,
2558}
2559
2560/// S3 ServerSideEncryptionByDefault.
2561#[derive(Debug, Clone, Default)]
2562pub struct ServerSideEncryptionByDefault {
2563    pub kms_master_key_id: Option<String>,
2564    pub sse_algorithm: ServerSideEncryption,
2565}
2566
2567/// S3 ServerSideEncryptionConfiguration.
2568#[derive(Debug, Clone, Default)]
2569pub struct ServerSideEncryptionConfiguration {
2570    pub rules: Vec<ServerSideEncryptionRule>,
2571}
2572
2573/// S3 ServerSideEncryptionRule.
2574#[derive(Debug, Clone, Default)]
2575pub struct ServerSideEncryptionRule {
2576    pub apply_server_side_encryption_by_default: Option<ServerSideEncryptionByDefault>,
2577    pub blocked_encryption_types: Option<BlockedEncryptionTypes>,
2578    pub bucket_key_enabled: Option<bool>,
2579}
2580
2581/// S3 SimplePrefix.
2582#[derive(Debug, Clone, Default)]
2583pub struct SimplePrefix {}
2584
2585/// S3 Tag.
2586#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2587pub struct Tag {
2588    pub key: String,
2589    pub value: String,
2590}
2591
2592/// S3 Tagging.
2593#[derive(Debug, Clone, Default)]
2594pub struct Tagging {
2595    pub tag_set: Vec<Tag>,
2596}
2597
2598/// S3 TargetGrant.
2599#[derive(Debug, Clone, Default)]
2600pub struct TargetGrant {
2601    pub grantee: Option<Grantee>,
2602    pub permission: Option<BucketLogsPermission>,
2603}
2604
2605/// S3 TargetObjectKeyFormat.
2606#[derive(Debug, Clone, Default)]
2607pub struct TargetObjectKeyFormat {
2608    pub partitioned_prefix: Option<PartitionedPrefix>,
2609    pub simple_prefix: Option<SimplePrefix>,
2610}
2611
2612/// S3 TopicConfiguration.
2613#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2614pub struct TopicConfiguration {
2615    pub events: Vec<Event>,
2616    pub filter: Option<NotificationConfigurationFilter>,
2617    pub id: Option<String>,
2618    pub topic_arn: String,
2619}
2620
2621/// S3 Transition.
2622#[derive(Debug, Clone, Default, Serialize, Deserialize)]
2623pub struct Transition {
2624    pub date: Option<chrono::DateTime<chrono::Utc>>,
2625    pub days: Option<i32>,
2626    pub storage_class: Option<TransitionStorageClass>,
2627}
2628
2629/// S3 VersioningConfiguration.
2630#[derive(Debug, Clone, Default)]
2631pub struct VersioningConfiguration {
2632    pub mfa_delete: Option<MFADelete>,
2633    pub status: Option<BucketVersioningStatus>,
2634}
2635
2636/// S3 WebsiteConfiguration.
2637#[derive(Debug, Clone, Default)]
2638pub struct WebsiteConfiguration {
2639    pub error_document: Option<ErrorDocument>,
2640    pub index_document: Option<IndexDocument>,
2641    pub redirect_all_requests_to: Option<RedirectAllRequestsTo>,
2642    pub routing_rules: Vec<RoutingRule>,
2643}
rustack_s3_model/types.rs

rustack_s3_model/
types.rs
