rustack_logs_model/
types.rs

1//! Auto-generated from AWS CloudWatch Logs Smithy model. DO NOT EDIT.
2
3use std::collections::HashMap;
4
5use serde::{Deserialize, Serialize};
6
7/// CloudWatch Logs DataProtectionStatus enum.
8#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
9pub enum DataProtectionStatus {
10    /// Default variant.
11    #[default]
12    #[serde(rename = "ACTIVATED")]
13    Activated,
14    #[serde(rename = "ARCHIVED")]
15    Archived,
16    #[serde(rename = "DELETED")]
17    Deleted,
18    #[serde(rename = "DISABLED")]
19    Disabled,
20}
21
22impl DataProtectionStatus {
23    /// Returns the string value of this enum variant.
24    #[must_use]
25    pub fn as_str(&self) -> &'static str {
26        match self {
27            Self::Activated => "ACTIVATED",
28            Self::Archived => "ARCHIVED",
29            Self::Deleted => "DELETED",
30            Self::Disabled => "DISABLED",
31        }
32    }
33}
34
35impl std::fmt::Display for DataProtectionStatus {
36    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
37        f.write_str(self.as_str())
38    }
39}
40
41impl From<&str> for DataProtectionStatus {
42    fn from(s: &str) -> Self {
43        match s {
44            "ACTIVATED" => Self::Activated,
45            "ARCHIVED" => Self::Archived,
46            "DELETED" => Self::Deleted,
47            "DISABLED" => Self::Disabled,
48            _ => Self::default(),
49        }
50    }
51}
52
53/// CloudWatch Logs Distribution enum.
54#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
55pub enum Distribution {
56    /// Default variant.
57    #[default]
58    ByLogStream,
59    Random,
60}
61
62impl Distribution {
63    /// Returns the string value of this enum variant.
64    #[must_use]
65    pub fn as_str(&self) -> &'static str {
66        match self {
67            Self::ByLogStream => "ByLogStream",
68            Self::Random => "Random",
69        }
70    }
71}
72
73impl std::fmt::Display for Distribution {
74    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
75        f.write_str(self.as_str())
76    }
77}
78
79impl From<&str> for Distribution {
80    fn from(s: &str) -> Self {
81        match s {
82            "ByLogStream" => Self::ByLogStream,
83            "Random" => Self::Random,
84            _ => Self::default(),
85        }
86    }
87}
88
89/// CloudWatch Logs EntityRejectionErrorType enum.
90#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
91pub enum EntityRejectionErrorType {
92    /// Default variant.
93    #[default]
94    EntitySizeTooLarge,
95    InvalidAttributes,
96    InvalidEntity,
97    #[serde(rename = "InvalidKeyAttributes")]
98    InvalidKeyAttribute,
99    InvalidTypeValue,
100    MissingRequiredFields,
101    UnsupportedLogGroupType,
102}
103
104impl EntityRejectionErrorType {
105    /// Returns the string value of this enum variant.
106    #[must_use]
107    pub fn as_str(&self) -> &'static str {
108        match self {
109            Self::EntitySizeTooLarge => "EntitySizeTooLarge",
110            Self::InvalidAttributes => "InvalidAttributes",
111            Self::InvalidEntity => "InvalidEntity",
112            Self::InvalidKeyAttribute => "InvalidKeyAttributes",
113            Self::InvalidTypeValue => "InvalidTypeValue",
114            Self::MissingRequiredFields => "MissingRequiredFields",
115            Self::UnsupportedLogGroupType => "UnsupportedLogGroupType",
116        }
117    }
118}
119
120impl std::fmt::Display for EntityRejectionErrorType {
121    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
122        f.write_str(self.as_str())
123    }
124}
125
126impl From<&str> for EntityRejectionErrorType {
127    fn from(s: &str) -> Self {
128        match s {
129            "EntitySizeTooLarge" => Self::EntitySizeTooLarge,
130            "InvalidAttributes" => Self::InvalidAttributes,
131            "InvalidEntity" => Self::InvalidEntity,
132            "InvalidKeyAttributes" => Self::InvalidKeyAttribute,
133            "InvalidTypeValue" => Self::InvalidTypeValue,
134            "MissingRequiredFields" => Self::MissingRequiredFields,
135            "UnsupportedLogGroupType" => Self::UnsupportedLogGroupType,
136            _ => Self::default(),
137        }
138    }
139}
140
141/// CloudWatch Logs ExportTaskStatusCode enum.
142#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
143pub enum ExportTaskStatusCode {
144    /// Default variant.
145    #[default]
146    #[serde(rename = "CANCELLED")]
147    Cancelled,
148    #[serde(rename = "COMPLETED")]
149    Completed,
150    #[serde(rename = "FAILED")]
151    Failed,
152    #[serde(rename = "PENDING")]
153    Pending,
154    #[serde(rename = "PENDING_CANCEL")]
155    PendingCancel,
156    #[serde(rename = "RUNNING")]
157    Running,
158}
159
160impl ExportTaskStatusCode {
161    /// Returns the string value of this enum variant.
162    #[must_use]
163    pub fn as_str(&self) -> &'static str {
164        match self {
165            Self::Cancelled => "CANCELLED",
166            Self::Completed => "COMPLETED",
167            Self::Failed => "FAILED",
168            Self::Pending => "PENDING",
169            Self::PendingCancel => "PENDING_CANCEL",
170            Self::Running => "RUNNING",
171        }
172    }
173}
174
175impl std::fmt::Display for ExportTaskStatusCode {
176    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
177        f.write_str(self.as_str())
178    }
179}
180
181impl From<&str> for ExportTaskStatusCode {
182    fn from(s: &str) -> Self {
183        match s {
184            "CANCELLED" => Self::Cancelled,
185            "COMPLETED" => Self::Completed,
186            "FAILED" => Self::Failed,
187            "PENDING" => Self::Pending,
188            "PENDING_CANCEL" => Self::PendingCancel,
189            "RUNNING" => Self::Running,
190            _ => Self::default(),
191        }
192    }
193}
194
195/// CloudWatch Logs InheritedProperty enum.
196#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
197pub enum InheritedProperty {
198    /// Default variant.
199    #[default]
200    #[serde(rename = "ACCOUNT_DATA_PROTECTION")]
201    AccountDataProtection,
202}
203
204impl InheritedProperty {
205    /// Returns the string value of this enum variant.
206    #[must_use]
207    pub fn as_str(&self) -> &'static str {
208        match self {
209            Self::AccountDataProtection => "ACCOUNT_DATA_PROTECTION",
210        }
211    }
212}
213
214impl std::fmt::Display for InheritedProperty {
215    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
216        f.write_str(self.as_str())
217    }
218}
219
220impl From<&str> for InheritedProperty {
221    fn from(s: &str) -> Self {
222        match s {
223            "ACCOUNT_DATA_PROTECTION" => Self::AccountDataProtection,
224            _ => Self::default(),
225        }
226    }
227}
228
229/// CloudWatch Logs LogGroupClass enum.
230#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
231pub enum LogGroupClass {
232    /// Default variant.
233    #[default]
234    #[serde(rename = "DELIVERY")]
235    Delivery,
236    #[serde(rename = "INFREQUENT_ACCESS")]
237    InfrequentAccess,
238    #[serde(rename = "STANDARD")]
239    Standard,
240}
241
242impl LogGroupClass {
243    /// Returns the string value of this enum variant.
244    #[must_use]
245    pub fn as_str(&self) -> &'static str {
246        match self {
247            Self::Delivery => "DELIVERY",
248            Self::InfrequentAccess => "INFREQUENT_ACCESS",
249            Self::Standard => "STANDARD",
250        }
251    }
252}
253
254impl std::fmt::Display for LogGroupClass {
255    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
256        f.write_str(self.as_str())
257    }
258}
259
260impl From<&str> for LogGroupClass {
261    fn from(s: &str) -> Self {
262        match s {
263            "DELIVERY" => Self::Delivery,
264            "INFREQUENT_ACCESS" => Self::InfrequentAccess,
265            "STANDARD" => Self::Standard,
266            _ => Self::default(),
267        }
268    }
269}
270
271/// CloudWatch Logs OrderBy enum.
272#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
273pub enum OrderBy {
274    /// Default variant.
275    #[default]
276    LastEventTime,
277    LogStreamName,
278}
279
280impl OrderBy {
281    /// Returns the string value of this enum variant.
282    #[must_use]
283    pub fn as_str(&self) -> &'static str {
284        match self {
285            Self::LastEventTime => "LastEventTime",
286            Self::LogStreamName => "LogStreamName",
287        }
288    }
289}
290
291impl std::fmt::Display for OrderBy {
292    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
293        f.write_str(self.as_str())
294    }
295}
296
297impl From<&str> for OrderBy {
298    fn from(s: &str) -> Self {
299        match s {
300            "LastEventTime" => Self::LastEventTime,
301            "LogStreamName" => Self::LogStreamName,
302            _ => Self::default(),
303        }
304    }
305}
306
307/// CloudWatch Logs PolicyScope enum.
308#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
309pub enum PolicyScope {
310    /// Default variant.
311    #[default]
312    #[serde(rename = "ACCOUNT")]
313    Account,
314    #[serde(rename = "RESOURCE")]
315    Resource,
316}
317
318impl PolicyScope {
319    /// Returns the string value of this enum variant.
320    #[must_use]
321    pub fn as_str(&self) -> &'static str {
322        match self {
323            Self::Account => "ACCOUNT",
324            Self::Resource => "RESOURCE",
325        }
326    }
327}
328
329impl std::fmt::Display for PolicyScope {
330    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
331        f.write_str(self.as_str())
332    }
333}
334
335impl From<&str> for PolicyScope {
336    fn from(s: &str) -> Self {
337        match s {
338            "ACCOUNT" => Self::Account,
339            "RESOURCE" => Self::Resource,
340            _ => Self::default(),
341        }
342    }
343}
344
345/// CloudWatch Logs QueryLanguage enum.
346#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
347pub enum QueryLanguage {
348    /// Default variant.
349    #[default]
350    #[serde(rename = "CWLI")]
351    Cwli,
352    #[serde(rename = "PPL")]
353    Ppl,
354    #[serde(rename = "SQL")]
355    Sql,
356}
357
358impl QueryLanguage {
359    /// Returns the string value of this enum variant.
360    #[must_use]
361    pub fn as_str(&self) -> &'static str {
362        match self {
363            Self::Cwli => "CWLI",
364            Self::Ppl => "PPL",
365            Self::Sql => "SQL",
366        }
367    }
368}
369
370impl std::fmt::Display for QueryLanguage {
371    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
372        f.write_str(self.as_str())
373    }
374}
375
376impl From<&str> for QueryLanguage {
377    fn from(s: &str) -> Self {
378        match s {
379            "CWLI" => Self::Cwli,
380            "PPL" => Self::Ppl,
381            "SQL" => Self::Sql,
382            _ => Self::default(),
383        }
384    }
385}
386
387/// CloudWatch Logs QueryStatus enum.
388#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
389pub enum QueryStatus {
390    /// Default variant.
391    #[default]
392    Cancelled,
393    Complete,
394    Failed,
395    Running,
396    Scheduled,
397    Timeout,
398    Unknown,
399}
400
401impl QueryStatus {
402    /// Returns the string value of this enum variant.
403    #[must_use]
404    pub fn as_str(&self) -> &'static str {
405        match self {
406            Self::Cancelled => "Cancelled",
407            Self::Complete => "Complete",
408            Self::Failed => "Failed",
409            Self::Running => "Running",
410            Self::Scheduled => "Scheduled",
411            Self::Timeout => "Timeout",
412            Self::Unknown => "Unknown",
413        }
414    }
415}
416
417impl std::fmt::Display for QueryStatus {
418    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
419        f.write_str(self.as_str())
420    }
421}
422
423impl From<&str> for QueryStatus {
424    fn from(s: &str) -> Self {
425        match s {
426            "Cancelled" => Self::Cancelled,
427            "Complete" => Self::Complete,
428            "Failed" => Self::Failed,
429            "Running" => Self::Running,
430            "Scheduled" => Self::Scheduled,
431            "Timeout" => Self::Timeout,
432            "Unknown" => Self::Unknown,
433            _ => Self::default(),
434        }
435    }
436}
437
438/// CloudWatch Logs StandardUnit enum.
439#[derive(Debug, Clone, PartialEq, Eq, Hash, Default, Serialize, Deserialize)]
440pub enum StandardUnit {
441    /// Default variant.
442    #[default]
443    Bits,
444    #[serde(rename = "Bits/Second")]
445    BitsSecond,
446    Bytes,
447    #[serde(rename = "Bytes/Second")]
448    BytesSecond,
449    Count,
450    #[serde(rename = "Count/Second")]
451    CountSecond,
452    Gigabits,
453    #[serde(rename = "Gigabits/Second")]
454    GigabitsSecond,
455    Gigabytes,
456    #[serde(rename = "Gigabytes/Second")]
457    GigabytesSecond,
458    Kilobits,
459    #[serde(rename = "Kilobits/Second")]
460    KilobitsSecond,
461    Kilobytes,
462    #[serde(rename = "Kilobytes/Second")]
463    KilobytesSecond,
464    Megabits,
465    #[serde(rename = "Megabits/Second")]
466    MegabitsSecond,
467    Megabytes,
468    #[serde(rename = "Megabytes/Second")]
469    MegabytesSecond,
470    Microseconds,
471    Milliseconds,
472    None,
473    Percent,
474    Seconds,
475    Terabits,
476    #[serde(rename = "Terabits/Second")]
477    TerabitsSecond,
478    Terabytes,
479    #[serde(rename = "Terabytes/Second")]
480    TerabytesSecond,
481}
482
483impl StandardUnit {
484    /// Returns the string value of this enum variant.
485    #[must_use]
486    pub fn as_str(&self) -> &'static str {
487        match self {
488            Self::Bits => "Bits",
489            Self::BitsSecond => "Bits/Second",
490            Self::Bytes => "Bytes",
491            Self::BytesSecond => "Bytes/Second",
492            Self::Count => "Count",
493            Self::CountSecond => "Count/Second",
494            Self::Gigabits => "Gigabits",
495            Self::GigabitsSecond => "Gigabits/Second",
496            Self::Gigabytes => "Gigabytes",
497            Self::GigabytesSecond => "Gigabytes/Second",
498            Self::Kilobits => "Kilobits",
499            Self::KilobitsSecond => "Kilobits/Second",
500            Self::Kilobytes => "Kilobytes",
501            Self::KilobytesSecond => "Kilobytes/Second",
502            Self::Megabits => "Megabits",
503            Self::MegabitsSecond => "Megabits/Second",
504            Self::Megabytes => "Megabytes",
505            Self::MegabytesSecond => "Megabytes/Second",
506            Self::Microseconds => "Microseconds",
507            Self::Milliseconds => "Milliseconds",
508            Self::None => "None",
509            Self::Percent => "Percent",
510            Self::Seconds => "Seconds",
511            Self::Terabits => "Terabits",
512            Self::TerabitsSecond => "Terabits/Second",
513            Self::Terabytes => "Terabytes",
514            Self::TerabytesSecond => "Terabytes/Second",
515        }
516    }
517}
518
519impl std::fmt::Display for StandardUnit {
520    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
521        f.write_str(self.as_str())
522    }
523}
524
525impl From<&str> for StandardUnit {
526    fn from(s: &str) -> Self {
527        match s {
528            "Bits" => Self::Bits,
529            "Bits/Second" => Self::BitsSecond,
530            "Bytes" => Self::Bytes,
531            "Bytes/Second" => Self::BytesSecond,
532            "Count" => Self::Count,
533            "Count/Second" => Self::CountSecond,
534            "Gigabits" => Self::Gigabits,
535            "Gigabits/Second" => Self::GigabitsSecond,
536            "Gigabytes" => Self::Gigabytes,
537            "Gigabytes/Second" => Self::GigabytesSecond,
538            "Kilobits" => Self::Kilobits,
539            "Kilobits/Second" => Self::KilobitsSecond,
540            "Kilobytes" => Self::Kilobytes,
541            "Kilobytes/Second" => Self::KilobytesSecond,
542            "Megabits" => Self::Megabits,
543            "Megabits/Second" => Self::MegabitsSecond,
544            "Megabytes" => Self::Megabytes,
545            "Megabytes/Second" => Self::MegabytesSecond,
546            "Microseconds" => Self::Microseconds,
547            "Milliseconds" => Self::Milliseconds,
548            "None" => Self::None,
549            "Percent" => Self::Percent,
550            "Seconds" => Self::Seconds,
551            "Terabits" => Self::Terabits,
552            "Terabits/Second" => Self::TerabitsSecond,
553            "Terabytes" => Self::Terabytes,
554            "Terabytes/Second" => Self::TerabytesSecond,
555            _ => Self::default(),
556        }
557    }
558}
559
560/// CloudWatch Logs Destination.
561#[derive(Debug, Clone, Default, Serialize, Deserialize)]
562#[serde(rename_all = "camelCase")]
563pub struct Destination {
564    #[serde(skip_serializing_if = "Option::is_none")]
565    pub access_policy: Option<String>,
566    #[serde(skip_serializing_if = "Option::is_none")]
567    pub arn: Option<String>,
568    #[serde(skip_serializing_if = "Option::is_none")]
569    pub creation_time: Option<i64>,
570    #[serde(skip_serializing_if = "Option::is_none")]
571    pub destination_name: Option<String>,
572    #[serde(skip_serializing_if = "Option::is_none")]
573    pub role_arn: Option<String>,
574    #[serde(skip_serializing_if = "Option::is_none")]
575    pub target_arn: Option<String>,
576}
577
578/// CloudWatch Logs Entity.
579#[derive(Debug, Clone, Default, Serialize, Deserialize)]
580#[serde(rename_all = "camelCase")]
581pub struct Entity {
582    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
583    pub attributes: HashMap<String, String>,
584    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
585    pub key_attributes: HashMap<String, String>,
586}
587
588/// CloudWatch Logs ExportTask.
589#[derive(Debug, Clone, Default, Serialize, Deserialize)]
590#[serde(rename_all = "camelCase")]
591pub struct ExportTask {
592    #[serde(skip_serializing_if = "Option::is_none")]
593    pub destination: Option<String>,
594    #[serde(skip_serializing_if = "Option::is_none")]
595    pub destination_prefix: Option<String>,
596    #[serde(skip_serializing_if = "Option::is_none")]
597    pub execution_info: Option<ExportTaskExecutionInfo>,
598    #[serde(skip_serializing_if = "Option::is_none")]
599    pub from: Option<i64>,
600    #[serde(skip_serializing_if = "Option::is_none")]
601    pub log_group_name: Option<String>,
602    #[serde(skip_serializing_if = "Option::is_none")]
603    pub status: Option<ExportTaskStatus>,
604    #[serde(skip_serializing_if = "Option::is_none")]
605    pub task_id: Option<String>,
606    #[serde(skip_serializing_if = "Option::is_none")]
607    pub task_name: Option<String>,
608    #[serde(skip_serializing_if = "Option::is_none")]
609    pub to: Option<i64>,
610}
611
612/// CloudWatch Logs ExportTaskExecutionInfo.
613#[derive(Debug, Clone, Default, Serialize, Deserialize)]
614#[serde(rename_all = "camelCase")]
615pub struct ExportTaskExecutionInfo {
616    #[serde(skip_serializing_if = "Option::is_none")]
617    pub completion_time: Option<i64>,
618    #[serde(skip_serializing_if = "Option::is_none")]
619    pub creation_time: Option<i64>,
620}
621
622/// CloudWatch Logs ExportTaskStatus.
623#[derive(Debug, Clone, Default, Serialize, Deserialize)]
624#[serde(rename_all = "camelCase")]
625pub struct ExportTaskStatus {
626    #[serde(skip_serializing_if = "Option::is_none")]
627    pub code: Option<ExportTaskStatusCode>,
628    #[serde(skip_serializing_if = "Option::is_none")]
629    pub message: Option<String>,
630}
631
632/// CloudWatch Logs FilteredLogEvent.
633#[derive(Debug, Clone, Default, Serialize, Deserialize)]
634#[serde(rename_all = "camelCase")]
635pub struct FilteredLogEvent {
636    #[serde(skip_serializing_if = "Option::is_none")]
637    pub event_id: Option<String>,
638    #[serde(skip_serializing_if = "Option::is_none")]
639    pub ingestion_time: Option<i64>,
640    #[serde(skip_serializing_if = "Option::is_none")]
641    pub log_stream_name: Option<String>,
642    #[serde(skip_serializing_if = "Option::is_none")]
643    pub message: Option<String>,
644    #[serde(skip_serializing_if = "Option::is_none")]
645    pub timestamp: Option<i64>,
646}
647
648/// CloudWatch Logs InputLogEvent.
649#[derive(Debug, Clone, Default, Serialize, Deserialize)]
650#[serde(rename_all = "camelCase")]
651pub struct InputLogEvent {
652    pub message: String,
653    pub timestamp: i64,
654}
655
656/// CloudWatch Logs LogGroup.
657#[derive(Debug, Clone, Default, Serialize, Deserialize)]
658#[serde(rename_all = "camelCase")]
659pub struct LogGroup {
660    #[serde(skip_serializing_if = "Option::is_none")]
661    pub arn: Option<String>,
662    #[serde(skip_serializing_if = "Option::is_none")]
663    pub bearer_token_authentication_enabled: Option<bool>,
664    #[serde(skip_serializing_if = "Option::is_none")]
665    pub creation_time: Option<i64>,
666    #[serde(skip_serializing_if = "Option::is_none")]
667    pub data_protection_status: Option<DataProtectionStatus>,
668    #[serde(skip_serializing_if = "Option::is_none")]
669    pub deletion_protection_enabled: Option<bool>,
670    #[serde(default, skip_serializing_if = "Vec::is_empty")]
671    pub inherited_properties: Vec<InheritedProperty>,
672    #[serde(skip_serializing_if = "Option::is_none")]
673    pub kms_key_id: Option<String>,
674    #[serde(skip_serializing_if = "Option::is_none")]
675    pub log_group_arn: Option<String>,
676    #[serde(skip_serializing_if = "Option::is_none")]
677    pub log_group_class: Option<LogGroupClass>,
678    #[serde(skip_serializing_if = "Option::is_none")]
679    pub log_group_name: Option<String>,
680    #[serde(skip_serializing_if = "Option::is_none")]
681    pub metric_filter_count: Option<i32>,
682    #[serde(skip_serializing_if = "Option::is_none")]
683    pub retention_in_days: Option<i32>,
684    #[serde(skip_serializing_if = "Option::is_none")]
685    pub stored_bytes: Option<i64>,
686}
687
688/// CloudWatch Logs LogStream.
689#[derive(Debug, Clone, Default, Serialize, Deserialize)]
690#[serde(rename_all = "camelCase")]
691pub struct LogStream {
692    #[serde(skip_serializing_if = "Option::is_none")]
693    pub arn: Option<String>,
694    #[serde(skip_serializing_if = "Option::is_none")]
695    pub creation_time: Option<i64>,
696    #[serde(skip_serializing_if = "Option::is_none")]
697    pub first_event_timestamp: Option<i64>,
698    #[serde(skip_serializing_if = "Option::is_none")]
699    pub last_event_timestamp: Option<i64>,
700    #[serde(skip_serializing_if = "Option::is_none")]
701    pub last_ingestion_time: Option<i64>,
702    #[serde(skip_serializing_if = "Option::is_none")]
703    pub log_stream_name: Option<String>,
704    #[serde(skip_serializing_if = "Option::is_none")]
705    pub stored_bytes: Option<i64>,
706    #[serde(skip_serializing_if = "Option::is_none")]
707    pub upload_sequence_token: Option<String>,
708}
709
710/// CloudWatch Logs MetricFilter.
711#[derive(Debug, Clone, Default, Serialize, Deserialize)]
712#[serde(rename_all = "camelCase")]
713pub struct MetricFilter {
714    #[serde(skip_serializing_if = "Option::is_none")]
715    pub apply_on_transformed_logs: Option<bool>,
716    #[serde(skip_serializing_if = "Option::is_none")]
717    pub creation_time: Option<i64>,
718    #[serde(default, skip_serializing_if = "Vec::is_empty")]
719    pub emit_system_field_dimensions: Vec<String>,
720    #[serde(skip_serializing_if = "Option::is_none")]
721    pub field_selection_criteria: Option<String>,
722    #[serde(skip_serializing_if = "Option::is_none")]
723    pub filter_name: Option<String>,
724    #[serde(skip_serializing_if = "Option::is_none")]
725    pub filter_pattern: Option<String>,
726    #[serde(skip_serializing_if = "Option::is_none")]
727    pub log_group_name: Option<String>,
728    #[serde(default, skip_serializing_if = "Vec::is_empty")]
729    pub metric_transformations: Vec<MetricTransformation>,
730}
731
732/// CloudWatch Logs MetricFilterMatchRecord.
733#[derive(Debug, Clone, Default, Serialize, Deserialize)]
734#[serde(rename_all = "camelCase")]
735pub struct MetricFilterMatchRecord {
736    #[serde(skip_serializing_if = "Option::is_none")]
737    pub event_message: Option<String>,
738    #[serde(skip_serializing_if = "Option::is_none")]
739    pub event_number: Option<i64>,
740    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
741    pub extracted_values: HashMap<String, String>,
742}
743
744/// CloudWatch Logs MetricTransformation.
745#[derive(Debug, Clone, Default, Serialize, Deserialize)]
746#[serde(rename_all = "camelCase")]
747pub struct MetricTransformation {
748    #[serde(skip_serializing_if = "Option::is_none")]
749    pub default_value: Option<f64>,
750    #[serde(default, skip_serializing_if = "HashMap::is_empty")]
751    pub dimensions: HashMap<String, String>,
752    pub metric_name: String,
753    pub metric_namespace: String,
754    pub metric_value: String,
755    #[serde(skip_serializing_if = "Option::is_none")]
756    pub unit: Option<StandardUnit>,
757}
758
759/// CloudWatch Logs OutputLogEvent.
760#[derive(Debug, Clone, Default, Serialize, Deserialize)]
761#[serde(rename_all = "camelCase")]
762pub struct OutputLogEvent {
763    #[serde(skip_serializing_if = "Option::is_none")]
764    pub ingestion_time: Option<i64>,
765    #[serde(skip_serializing_if = "Option::is_none")]
766    pub message: Option<String>,
767    #[serde(skip_serializing_if = "Option::is_none")]
768    pub timestamp: Option<i64>,
769}
770
771/// CloudWatch Logs QueryDefinition.
772#[derive(Debug, Clone, Default, Serialize, Deserialize)]
773#[serde(rename_all = "camelCase")]
774pub struct QueryDefinition {
775    #[serde(skip_serializing_if = "Option::is_none")]
776    pub last_modified: Option<i64>,
777    #[serde(default, skip_serializing_if = "Vec::is_empty")]
778    pub log_group_names: Vec<String>,
779    #[serde(skip_serializing_if = "Option::is_none")]
780    pub name: Option<String>,
781    #[serde(skip_serializing_if = "Option::is_none")]
782    pub query_definition_id: Option<String>,
783    #[serde(skip_serializing_if = "Option::is_none")]
784    pub query_language: Option<QueryLanguage>,
785    #[serde(skip_serializing_if = "Option::is_none")]
786    pub query_string: Option<String>,
787}
788
789/// CloudWatch Logs QueryInfo.
790#[derive(Debug, Clone, Default, Serialize, Deserialize)]
791#[serde(rename_all = "camelCase")]
792pub struct QueryInfo {
793    #[serde(skip_serializing_if = "Option::is_none")]
794    pub create_time: Option<i64>,
795    #[serde(skip_serializing_if = "Option::is_none")]
796    pub log_group_name: Option<String>,
797    #[serde(skip_serializing_if = "Option::is_none")]
798    pub query_id: Option<String>,
799    #[serde(skip_serializing_if = "Option::is_none")]
800    pub query_language: Option<QueryLanguage>,
801    #[serde(skip_serializing_if = "Option::is_none")]
802    pub query_string: Option<String>,
803    #[serde(skip_serializing_if = "Option::is_none")]
804    pub status: Option<QueryStatus>,
805}
806
807/// CloudWatch Logs QueryStatistics.
808#[derive(Debug, Clone, Default, Serialize, Deserialize)]
809#[serde(rename_all = "camelCase")]
810pub struct QueryStatistics {
811    #[serde(skip_serializing_if = "Option::is_none")]
812    pub bytes_scanned: Option<f64>,
813    #[serde(skip_serializing_if = "Option::is_none")]
814    pub estimated_bytes_skipped: Option<f64>,
815    #[serde(skip_serializing_if = "Option::is_none")]
816    pub estimated_records_skipped: Option<f64>,
817    #[serde(skip_serializing_if = "Option::is_none")]
818    pub log_groups_scanned: Option<f64>,
819    #[serde(skip_serializing_if = "Option::is_none")]
820    pub records_matched: Option<f64>,
821    #[serde(skip_serializing_if = "Option::is_none")]
822    pub records_scanned: Option<f64>,
823}
824
825/// CloudWatch Logs RejectedEntityInfo.
826#[derive(Debug, Clone, Default, Serialize, Deserialize)]
827#[serde(rename_all = "camelCase")]
828pub struct RejectedEntityInfo {
829    pub error_type: EntityRejectionErrorType,
830}
831
832/// CloudWatch Logs RejectedLogEventsInfo.
833#[derive(Debug, Clone, Default, Serialize, Deserialize)]
834#[serde(rename_all = "camelCase")]
835pub struct RejectedLogEventsInfo {
836    #[serde(skip_serializing_if = "Option::is_none")]
837    pub expired_log_event_end_index: Option<i32>,
838    #[serde(skip_serializing_if = "Option::is_none")]
839    pub too_new_log_event_start_index: Option<i32>,
840    #[serde(skip_serializing_if = "Option::is_none")]
841    pub too_old_log_event_end_index: Option<i32>,
842}
843
844/// CloudWatch Logs ResourcePolicy.
845#[derive(Debug, Clone, Default, Serialize, Deserialize)]
846#[serde(rename_all = "camelCase")]
847pub struct ResourcePolicy {
848    #[serde(skip_serializing_if = "Option::is_none")]
849    pub last_updated_time: Option<i64>,
850    #[serde(skip_serializing_if = "Option::is_none")]
851    pub policy_document: Option<String>,
852    #[serde(skip_serializing_if = "Option::is_none")]
853    pub policy_name: Option<String>,
854    #[serde(skip_serializing_if = "Option::is_none")]
855    pub policy_scope: Option<PolicyScope>,
856    #[serde(skip_serializing_if = "Option::is_none")]
857    pub resource_arn: Option<String>,
858    #[serde(skip_serializing_if = "Option::is_none")]
859    pub revision_id: Option<String>,
860}
861
862/// CloudWatch Logs ResultField.
863#[derive(Debug, Clone, Default, Serialize, Deserialize)]
864#[serde(rename_all = "camelCase")]
865pub struct ResultField {
866    #[serde(skip_serializing_if = "Option::is_none")]
867    pub field: Option<String>,
868    #[serde(skip_serializing_if = "Option::is_none")]
869    pub value: Option<String>,
870}
871
872/// CloudWatch Logs SearchedLogStream.
873#[derive(Debug, Clone, Default, Serialize, Deserialize)]
874#[serde(rename_all = "camelCase")]
875pub struct SearchedLogStream {
876    #[serde(skip_serializing_if = "Option::is_none")]
877    pub log_stream_name: Option<String>,
878    #[serde(skip_serializing_if = "Option::is_none")]
879    pub searched_completely: Option<bool>,
880}
881
882/// CloudWatch Logs SubscriptionFilter.
883#[derive(Debug, Clone, Default, Serialize, Deserialize)]
884#[serde(rename_all = "camelCase")]
885pub struct SubscriptionFilter {
886    #[serde(skip_serializing_if = "Option::is_none")]
887    pub apply_on_transformed_logs: Option<bool>,
888    #[serde(skip_serializing_if = "Option::is_none")]
889    pub creation_time: Option<i64>,
890    #[serde(skip_serializing_if = "Option::is_none")]
891    pub destination_arn: Option<String>,
892    #[serde(skip_serializing_if = "Option::is_none")]
893    pub distribution: Option<Distribution>,
894    #[serde(default, skip_serializing_if = "Vec::is_empty")]
895    pub emit_system_fields: Vec<String>,
896    #[serde(skip_serializing_if = "Option::is_none")]
897    pub field_selection_criteria: Option<String>,
898    #[serde(skip_serializing_if = "Option::is_none")]
899    pub filter_name: Option<String>,
900    #[serde(skip_serializing_if = "Option::is_none")]
901    pub filter_pattern: Option<String>,
902    #[serde(skip_serializing_if = "Option::is_none")]
903    pub log_group_name: Option<String>,
904    #[serde(skip_serializing_if = "Option::is_none")]
905    pub role_arn: Option<String>,
906}
rustack_logs_model/types.rs

rustack_logs_model/
types.rs
