Skip to main content

clickhouse_cloud_api/
models.rs

1//! Typed models for ClickHouse Cloud API schemas.
2//!
3//! Auto-generated from the OpenAPI specification.
4
5use serde::{Deserialize, Serialize};
6
7/// `pgHaType` enum from the ClickHouse Cloud API.
8#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9pub enum PgHaType {
10    #[serde(rename = "none")]
11    #[default]
12    None,
13    #[serde(rename = "async")]
14    Async,
15    #[serde(rename = "sync")]
16    Sync,
17    /// Catch-all for unknown or newly-added values.
18    #[serde(untagged)]
19    Unknown(String),
20}
21
22impl std::fmt::Display for PgHaType {
23    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
24        match self {
25            Self::None => write!(f, "none"),
26            Self::Async => write!(f, "async"),
27            Self::Sync => write!(f, "sync"),
28            Self::Unknown(s) => write!(f, "{s}"),
29        }
30    }
31}
32
33/// `pgProvider` enum from the ClickHouse Cloud API.
34#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
35pub enum PgProvider {
36    #[serde(rename = "aws")]
37    #[default]
38    Aws,
39    /// Catch-all for unknown or newly-added values.
40    #[serde(untagged)]
41    Unknown(String),
42}
43
44impl std::fmt::Display for PgProvider {
45    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
46        match self {
47            Self::Aws => write!(f, "aws"),
48            Self::Unknown(s) => write!(f, "{s}"),
49        }
50    }
51}
52
53/// `pgSize` enum from the ClickHouse Cloud API.
54#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
55pub enum PgSize {
56    #[serde(rename = "c6gd.medium")]
57    #[default]
58    C6gd_medium,
59    #[serde(rename = "c6gd.large")]
60    C6gd_large,
61    #[serde(rename = "c6gd.xlarge")]
62    C6gd_xlarge,
63    #[serde(rename = "c6gd.2xlarge")]
64    C6gd_2xlarge,
65    #[serde(rename = "c6gd.4xlarge")]
66    C6gd_4xlarge,
67    #[serde(rename = "c6gd.8xlarge")]
68    C6gd_8xlarge,
69    #[serde(rename = "c6gd.12xlarge")]
70    C6gd_12xlarge,
71    #[serde(rename = "c6gd.16xlarge")]
72    C6gd_16xlarge,
73    #[serde(rename = "c6gd.metal")]
74    C6gd_metal,
75    #[serde(rename = "i7i.large")]
76    I7i_large,
77    #[serde(rename = "i7i.xlarge")]
78    I7i_xlarge,
79    #[serde(rename = "i7i.2xlarge")]
80    I7i_2xlarge,
81    #[serde(rename = "i7i.4xlarge")]
82    I7i_4xlarge,
83    #[serde(rename = "i7i.8xlarge")]
84    I7i_8xlarge,
85    #[serde(rename = "i7i.12xlarge")]
86    I7i_12xlarge,
87    #[serde(rename = "i7i.16xlarge")]
88    I7i_16xlarge,
89    #[serde(rename = "i7i.24xlarge")]
90    I7i_24xlarge,
91    #[serde(rename = "i7i.metal-24xl")]
92    I7i_metal_24xl,
93    #[serde(rename = "i7i.48xlarge")]
94    I7i_48xlarge,
95    #[serde(rename = "i7i.metal-48xl")]
96    I7i_metal_48xl,
97    #[serde(rename = "i7ie.large")]
98    I7ie_large,
99    #[serde(rename = "i7ie.xlarge")]
100    I7ie_xlarge,
101    #[serde(rename = "i7ie.2xlarge")]
102    I7ie_2xlarge,
103    #[serde(rename = "i7ie.3xlarge")]
104    I7ie_3xlarge,
105    #[serde(rename = "i7ie.6xlarge")]
106    I7ie_6xlarge,
107    #[serde(rename = "i7ie.12xlarge")]
108    I7ie_12xlarge,
109    #[serde(rename = "i7ie.18xlarge")]
110    I7ie_18xlarge,
111    #[serde(rename = "i7ie.24xlarge")]
112    I7ie_24xlarge,
113    #[serde(rename = "i7ie.metal-24xl")]
114    I7ie_metal_24xl,
115    #[serde(rename = "i7ie.48xlarge")]
116    I7ie_48xlarge,
117    #[serde(rename = "i7ie.metal-48xl")]
118    I7ie_metal_48xl,
119    #[serde(rename = "i8g.large")]
120    I8g_large,
121    #[serde(rename = "i8g.xlarge")]
122    I8g_xlarge,
123    #[serde(rename = "i8g.2xlarge")]
124    I8g_2xlarge,
125    #[serde(rename = "i8g.4xlarge")]
126    I8g_4xlarge,
127    #[serde(rename = "i8g.8xlarge")]
128    I8g_8xlarge,
129    #[serde(rename = "i8g.12xlarge")]
130    I8g_12xlarge,
131    #[serde(rename = "i8g.16xlarge")]
132    I8g_16xlarge,
133    #[serde(rename = "i8g.24xlarge")]
134    I8g_24xlarge,
135    #[serde(rename = "i8g.metal-24xl")]
136    I8g_metal_24xl,
137    #[serde(rename = "i8g.48xlarge")]
138    I8g_48xlarge,
139    #[serde(rename = "i8ge.large")]
140    I8ge_large,
141    #[serde(rename = "i8ge.xlarge")]
142    I8ge_xlarge,
143    #[serde(rename = "i8ge.2xlarge")]
144    I8ge_2xlarge,
145    #[serde(rename = "i8ge.3xlarge")]
146    I8ge_3xlarge,
147    #[serde(rename = "i8ge.6xlarge")]
148    I8ge_6xlarge,
149    #[serde(rename = "i8ge.12xlarge")]
150    I8ge_12xlarge,
151    #[serde(rename = "i8ge.18xlarge")]
152    I8ge_18xlarge,
153    #[serde(rename = "i8ge.24xlarge")]
154    I8ge_24xlarge,
155    #[serde(rename = "i8ge.metal-24xl")]
156    I8ge_metal_24xl,
157    #[serde(rename = "i8ge.48xlarge")]
158    I8ge_48xlarge,
159    #[serde(rename = "i8ge.metal-48xl")]
160    I8ge_metal_48xl,
161    #[serde(rename = "m6a.large")]
162    M6a_large,
163    #[serde(rename = "m6a.xlarge")]
164    M6a_xlarge,
165    #[serde(rename = "m6a.2xlarge")]
166    M6a_2xlarge,
167    #[serde(rename = "m6a.4xlarge")]
168    M6a_4xlarge,
169    #[serde(rename = "m6a.8xlarge")]
170    M6a_8xlarge,
171    #[serde(rename = "m6a.12xlarge")]
172    M6a_12xlarge,
173    #[serde(rename = "m6a.16xlarge")]
174    M6a_16xlarge,
175    #[serde(rename = "m6a.24xlarge")]
176    M6a_24xlarge,
177    #[serde(rename = "m6a.32xlarge")]
178    M6a_32xlarge,
179    #[serde(rename = "m6a.48xlarge")]
180    M6a_48xlarge,
181    #[serde(rename = "m6a.metal")]
182    M6a_metal,
183    #[serde(rename = "m6gd.medium")]
184    M6gd_medium,
185    #[serde(rename = "m6gd.large")]
186    M6gd_large,
187    #[serde(rename = "m6gd.xlarge")]
188    M6gd_xlarge,
189    #[serde(rename = "m6gd.2xlarge")]
190    M6gd_2xlarge,
191    #[serde(rename = "m6gd.4xlarge")]
192    M6gd_4xlarge,
193    #[serde(rename = "m6gd.8xlarge")]
194    M6gd_8xlarge,
195    #[serde(rename = "m6gd.12xlarge")]
196    M6gd_12xlarge,
197    #[serde(rename = "m6gd.16xlarge")]
198    M6gd_16xlarge,
199    #[serde(rename = "m6gd.metal")]
200    M6gd_metal,
201    #[serde(rename = "m6id.large")]
202    M6id_large,
203    #[serde(rename = "m6id.xlarge")]
204    M6id_xlarge,
205    #[serde(rename = "m6id.2xlarge")]
206    M6id_2xlarge,
207    #[serde(rename = "m6id.4xlarge")]
208    M6id_4xlarge,
209    #[serde(rename = "m6id.8xlarge")]
210    M6id_8xlarge,
211    #[serde(rename = "m6id.12xlarge")]
212    M6id_12xlarge,
213    #[serde(rename = "m6id.16xlarge")]
214    M6id_16xlarge,
215    #[serde(rename = "m6id.24xlarge")]
216    M6id_24xlarge,
217    #[serde(rename = "m6id.32xlarge")]
218    M6id_32xlarge,
219    #[serde(rename = "m6id.metal")]
220    M6id_metal,
221    #[serde(rename = "m7a.medium")]
222    M7a_medium,
223    #[serde(rename = "m7a.large")]
224    M7a_large,
225    #[serde(rename = "m7a.xlarge")]
226    M7a_xlarge,
227    #[serde(rename = "m7a.2xlarge")]
228    M7a_2xlarge,
229    #[serde(rename = "m7a.4xlarge")]
230    M7a_4xlarge,
231    #[serde(rename = "m7a.8xlarge")]
232    M7a_8xlarge,
233    #[serde(rename = "m7a.12xlarge")]
234    M7a_12xlarge,
235    #[serde(rename = "m7a.16xlarge")]
236    M7a_16xlarge,
237    #[serde(rename = "m7a.24xlarge")]
238    M7a_24xlarge,
239    #[serde(rename = "m7a.32xlarge")]
240    M7a_32xlarge,
241    #[serde(rename = "m7a.48xlarge")]
242    M7a_48xlarge,
243    #[serde(rename = "m7a.metal-48xl")]
244    M7a_metal_48xl,
245    #[serde(rename = "m7i.large")]
246    M7i_large,
247    #[serde(rename = "m7i.xlarge")]
248    M7i_xlarge,
249    #[serde(rename = "m7i.2xlarge")]
250    M7i_2xlarge,
251    #[serde(rename = "m7i.4xlarge")]
252    M7i_4xlarge,
253    #[serde(rename = "m7i.8xlarge")]
254    M7i_8xlarge,
255    #[serde(rename = "m7i.12xlarge")]
256    M7i_12xlarge,
257    #[serde(rename = "m7i.16xlarge")]
258    M7i_16xlarge,
259    #[serde(rename = "m7i.24xlarge")]
260    M7i_24xlarge,
261    #[serde(rename = "m7i.metal-24xl")]
262    M7i_metal_24xl,
263    #[serde(rename = "m7i.48xlarge")]
264    M7i_48xlarge,
265    #[serde(rename = "m7i.metal-48xl")]
266    M7i_metal_48xl,
267    #[serde(rename = "m8gd.medium")]
268    M8gd_medium,
269    #[serde(rename = "m8gd.large")]
270    M8gd_large,
271    #[serde(rename = "m8gd.xlarge")]
272    M8gd_xlarge,
273    #[serde(rename = "m8gd.2xlarge")]
274    M8gd_2xlarge,
275    #[serde(rename = "m8gd.4xlarge")]
276    M8gd_4xlarge,
277    #[serde(rename = "m8gd.8xlarge")]
278    M8gd_8xlarge,
279    #[serde(rename = "m8gd.12xlarge")]
280    M8gd_12xlarge,
281    #[serde(rename = "m8gd.16xlarge")]
282    M8gd_16xlarge,
283    #[serde(rename = "m8gd.24xlarge")]
284    M8gd_24xlarge,
285    #[serde(rename = "m8gd.metal-24xl")]
286    M8gd_metal_24xl,
287    #[serde(rename = "m8gd.48xlarge")]
288    M8gd_48xlarge,
289    #[serde(rename = "m8gd.metal-48xl")]
290    M8gd_metal_48xl,
291    #[serde(rename = "r6gd.medium")]
292    R6gd_medium,
293    #[serde(rename = "r6gd.large")]
294    R6gd_large,
295    #[serde(rename = "r6gd.xlarge")]
296    R6gd_xlarge,
297    #[serde(rename = "r6gd.2xlarge")]
298    R6gd_2xlarge,
299    #[serde(rename = "r6gd.4xlarge")]
300    R6gd_4xlarge,
301    #[serde(rename = "r6gd.8xlarge")]
302    R6gd_8xlarge,
303    #[serde(rename = "r6gd.12xlarge")]
304    R6gd_12xlarge,
305    #[serde(rename = "r6gd.16xlarge")]
306    R6gd_16xlarge,
307    #[serde(rename = "r6gd.metal")]
308    R6gd_metal,
309    #[serde(rename = "r6id.large")]
310    R6id_large,
311    #[serde(rename = "r6id.xlarge")]
312    R6id_xlarge,
313    #[serde(rename = "r6id.2xlarge")]
314    R6id_2xlarge,
315    #[serde(rename = "r6id.4xlarge")]
316    R6id_4xlarge,
317    #[serde(rename = "r6id.8xlarge")]
318    R6id_8xlarge,
319    #[serde(rename = "r6id.12xlarge")]
320    R6id_12xlarge,
321    #[serde(rename = "r6id.16xlarge")]
322    R6id_16xlarge,
323    #[serde(rename = "r6id.24xlarge")]
324    R6id_24xlarge,
325    #[serde(rename = "r6id.32xlarge")]
326    R6id_32xlarge,
327    #[serde(rename = "r6id.metal")]
328    R6id_metal,
329    #[serde(rename = "r8gd.medium")]
330    R8gd_medium,
331    #[serde(rename = "r8gd.large")]
332    R8gd_large,
333    #[serde(rename = "r8gd.xlarge")]
334    R8gd_xlarge,
335    #[serde(rename = "r8gd.2xlarge")]
336    R8gd_2xlarge,
337    #[serde(rename = "r8gd.4xlarge")]
338    R8gd_4xlarge,
339    #[serde(rename = "r8gd.8xlarge")]
340    R8gd_8xlarge,
341    #[serde(rename = "r8gd.12xlarge")]
342    R8gd_12xlarge,
343    #[serde(rename = "r8gd.16xlarge")]
344    R8gd_16xlarge,
345    #[serde(rename = "r8gd.24xlarge")]
346    R8gd_24xlarge,
347    #[serde(rename = "r8gd.metal-24xl")]
348    R8gd_metal_24xl,
349    #[serde(rename = "r8gd.48xlarge")]
350    R8gd_48xlarge,
351    #[serde(rename = "r8gd.metal-48xl")]
352    R8gd_metal_48xl,
353    /// Catch-all for unknown or newly-added values.
354    #[serde(untagged)]
355    Unknown(String),
356}
357
358impl std::fmt::Display for PgSize {
359    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
360        match self {
361            Self::C6gd_medium => write!(f, "c6gd.medium"),
362            Self::C6gd_large => write!(f, "c6gd.large"),
363            Self::C6gd_xlarge => write!(f, "c6gd.xlarge"),
364            Self::C6gd_2xlarge => write!(f, "c6gd.2xlarge"),
365            Self::C6gd_4xlarge => write!(f, "c6gd.4xlarge"),
366            Self::C6gd_8xlarge => write!(f, "c6gd.8xlarge"),
367            Self::C6gd_12xlarge => write!(f, "c6gd.12xlarge"),
368            Self::C6gd_16xlarge => write!(f, "c6gd.16xlarge"),
369            Self::C6gd_metal => write!(f, "c6gd.metal"),
370            Self::I7i_large => write!(f, "i7i.large"),
371            Self::I7i_xlarge => write!(f, "i7i.xlarge"),
372            Self::I7i_2xlarge => write!(f, "i7i.2xlarge"),
373            Self::I7i_4xlarge => write!(f, "i7i.4xlarge"),
374            Self::I7i_8xlarge => write!(f, "i7i.8xlarge"),
375            Self::I7i_12xlarge => write!(f, "i7i.12xlarge"),
376            Self::I7i_16xlarge => write!(f, "i7i.16xlarge"),
377            Self::I7i_24xlarge => write!(f, "i7i.24xlarge"),
378            Self::I7i_metal_24xl => write!(f, "i7i.metal-24xl"),
379            Self::I7i_48xlarge => write!(f, "i7i.48xlarge"),
380            Self::I7i_metal_48xl => write!(f, "i7i.metal-48xl"),
381            Self::I7ie_large => write!(f, "i7ie.large"),
382            Self::I7ie_xlarge => write!(f, "i7ie.xlarge"),
383            Self::I7ie_2xlarge => write!(f, "i7ie.2xlarge"),
384            Self::I7ie_3xlarge => write!(f, "i7ie.3xlarge"),
385            Self::I7ie_6xlarge => write!(f, "i7ie.6xlarge"),
386            Self::I7ie_12xlarge => write!(f, "i7ie.12xlarge"),
387            Self::I7ie_18xlarge => write!(f, "i7ie.18xlarge"),
388            Self::I7ie_24xlarge => write!(f, "i7ie.24xlarge"),
389            Self::I7ie_metal_24xl => write!(f, "i7ie.metal-24xl"),
390            Self::I7ie_48xlarge => write!(f, "i7ie.48xlarge"),
391            Self::I7ie_metal_48xl => write!(f, "i7ie.metal-48xl"),
392            Self::I8g_large => write!(f, "i8g.large"),
393            Self::I8g_xlarge => write!(f, "i8g.xlarge"),
394            Self::I8g_2xlarge => write!(f, "i8g.2xlarge"),
395            Self::I8g_4xlarge => write!(f, "i8g.4xlarge"),
396            Self::I8g_8xlarge => write!(f, "i8g.8xlarge"),
397            Self::I8g_12xlarge => write!(f, "i8g.12xlarge"),
398            Self::I8g_16xlarge => write!(f, "i8g.16xlarge"),
399            Self::I8g_24xlarge => write!(f, "i8g.24xlarge"),
400            Self::I8g_metal_24xl => write!(f, "i8g.metal-24xl"),
401            Self::I8g_48xlarge => write!(f, "i8g.48xlarge"),
402            Self::I8ge_large => write!(f, "i8ge.large"),
403            Self::I8ge_xlarge => write!(f, "i8ge.xlarge"),
404            Self::I8ge_2xlarge => write!(f, "i8ge.2xlarge"),
405            Self::I8ge_3xlarge => write!(f, "i8ge.3xlarge"),
406            Self::I8ge_6xlarge => write!(f, "i8ge.6xlarge"),
407            Self::I8ge_12xlarge => write!(f, "i8ge.12xlarge"),
408            Self::I8ge_18xlarge => write!(f, "i8ge.18xlarge"),
409            Self::I8ge_24xlarge => write!(f, "i8ge.24xlarge"),
410            Self::I8ge_metal_24xl => write!(f, "i8ge.metal-24xl"),
411            Self::I8ge_48xlarge => write!(f, "i8ge.48xlarge"),
412            Self::I8ge_metal_48xl => write!(f, "i8ge.metal-48xl"),
413            Self::M6a_large => write!(f, "m6a.large"),
414            Self::M6a_xlarge => write!(f, "m6a.xlarge"),
415            Self::M6a_2xlarge => write!(f, "m6a.2xlarge"),
416            Self::M6a_4xlarge => write!(f, "m6a.4xlarge"),
417            Self::M6a_8xlarge => write!(f, "m6a.8xlarge"),
418            Self::M6a_12xlarge => write!(f, "m6a.12xlarge"),
419            Self::M6a_16xlarge => write!(f, "m6a.16xlarge"),
420            Self::M6a_24xlarge => write!(f, "m6a.24xlarge"),
421            Self::M6a_32xlarge => write!(f, "m6a.32xlarge"),
422            Self::M6a_48xlarge => write!(f, "m6a.48xlarge"),
423            Self::M6a_metal => write!(f, "m6a.metal"),
424            Self::M6gd_medium => write!(f, "m6gd.medium"),
425            Self::M6gd_large => write!(f, "m6gd.large"),
426            Self::M6gd_xlarge => write!(f, "m6gd.xlarge"),
427            Self::M6gd_2xlarge => write!(f, "m6gd.2xlarge"),
428            Self::M6gd_4xlarge => write!(f, "m6gd.4xlarge"),
429            Self::M6gd_8xlarge => write!(f, "m6gd.8xlarge"),
430            Self::M6gd_12xlarge => write!(f, "m6gd.12xlarge"),
431            Self::M6gd_16xlarge => write!(f, "m6gd.16xlarge"),
432            Self::M6gd_metal => write!(f, "m6gd.metal"),
433            Self::M6id_large => write!(f, "m6id.large"),
434            Self::M6id_xlarge => write!(f, "m6id.xlarge"),
435            Self::M6id_2xlarge => write!(f, "m6id.2xlarge"),
436            Self::M6id_4xlarge => write!(f, "m6id.4xlarge"),
437            Self::M6id_8xlarge => write!(f, "m6id.8xlarge"),
438            Self::M6id_12xlarge => write!(f, "m6id.12xlarge"),
439            Self::M6id_16xlarge => write!(f, "m6id.16xlarge"),
440            Self::M6id_24xlarge => write!(f, "m6id.24xlarge"),
441            Self::M6id_32xlarge => write!(f, "m6id.32xlarge"),
442            Self::M6id_metal => write!(f, "m6id.metal"),
443            Self::M7a_medium => write!(f, "m7a.medium"),
444            Self::M7a_large => write!(f, "m7a.large"),
445            Self::M7a_xlarge => write!(f, "m7a.xlarge"),
446            Self::M7a_2xlarge => write!(f, "m7a.2xlarge"),
447            Self::M7a_4xlarge => write!(f, "m7a.4xlarge"),
448            Self::M7a_8xlarge => write!(f, "m7a.8xlarge"),
449            Self::M7a_12xlarge => write!(f, "m7a.12xlarge"),
450            Self::M7a_16xlarge => write!(f, "m7a.16xlarge"),
451            Self::M7a_24xlarge => write!(f, "m7a.24xlarge"),
452            Self::M7a_32xlarge => write!(f, "m7a.32xlarge"),
453            Self::M7a_48xlarge => write!(f, "m7a.48xlarge"),
454            Self::M7a_metal_48xl => write!(f, "m7a.metal-48xl"),
455            Self::M7i_large => write!(f, "m7i.large"),
456            Self::M7i_xlarge => write!(f, "m7i.xlarge"),
457            Self::M7i_2xlarge => write!(f, "m7i.2xlarge"),
458            Self::M7i_4xlarge => write!(f, "m7i.4xlarge"),
459            Self::M7i_8xlarge => write!(f, "m7i.8xlarge"),
460            Self::M7i_12xlarge => write!(f, "m7i.12xlarge"),
461            Self::M7i_16xlarge => write!(f, "m7i.16xlarge"),
462            Self::M7i_24xlarge => write!(f, "m7i.24xlarge"),
463            Self::M7i_metal_24xl => write!(f, "m7i.metal-24xl"),
464            Self::M7i_48xlarge => write!(f, "m7i.48xlarge"),
465            Self::M7i_metal_48xl => write!(f, "m7i.metal-48xl"),
466            Self::M8gd_medium => write!(f, "m8gd.medium"),
467            Self::M8gd_large => write!(f, "m8gd.large"),
468            Self::M8gd_xlarge => write!(f, "m8gd.xlarge"),
469            Self::M8gd_2xlarge => write!(f, "m8gd.2xlarge"),
470            Self::M8gd_4xlarge => write!(f, "m8gd.4xlarge"),
471            Self::M8gd_8xlarge => write!(f, "m8gd.8xlarge"),
472            Self::M8gd_12xlarge => write!(f, "m8gd.12xlarge"),
473            Self::M8gd_16xlarge => write!(f, "m8gd.16xlarge"),
474            Self::M8gd_24xlarge => write!(f, "m8gd.24xlarge"),
475            Self::M8gd_metal_24xl => write!(f, "m8gd.metal-24xl"),
476            Self::M8gd_48xlarge => write!(f, "m8gd.48xlarge"),
477            Self::M8gd_metal_48xl => write!(f, "m8gd.metal-48xl"),
478            Self::R6gd_medium => write!(f, "r6gd.medium"),
479            Self::R6gd_large => write!(f, "r6gd.large"),
480            Self::R6gd_xlarge => write!(f, "r6gd.xlarge"),
481            Self::R6gd_2xlarge => write!(f, "r6gd.2xlarge"),
482            Self::R6gd_4xlarge => write!(f, "r6gd.4xlarge"),
483            Self::R6gd_8xlarge => write!(f, "r6gd.8xlarge"),
484            Self::R6gd_12xlarge => write!(f, "r6gd.12xlarge"),
485            Self::R6gd_16xlarge => write!(f, "r6gd.16xlarge"),
486            Self::R6gd_metal => write!(f, "r6gd.metal"),
487            Self::R6id_large => write!(f, "r6id.large"),
488            Self::R6id_xlarge => write!(f, "r6id.xlarge"),
489            Self::R6id_2xlarge => write!(f, "r6id.2xlarge"),
490            Self::R6id_4xlarge => write!(f, "r6id.4xlarge"),
491            Self::R6id_8xlarge => write!(f, "r6id.8xlarge"),
492            Self::R6id_12xlarge => write!(f, "r6id.12xlarge"),
493            Self::R6id_16xlarge => write!(f, "r6id.16xlarge"),
494            Self::R6id_24xlarge => write!(f, "r6id.24xlarge"),
495            Self::R6id_32xlarge => write!(f, "r6id.32xlarge"),
496            Self::R6id_metal => write!(f, "r6id.metal"),
497            Self::R8gd_medium => write!(f, "r8gd.medium"),
498            Self::R8gd_large => write!(f, "r8gd.large"),
499            Self::R8gd_xlarge => write!(f, "r8gd.xlarge"),
500            Self::R8gd_2xlarge => write!(f, "r8gd.2xlarge"),
501            Self::R8gd_4xlarge => write!(f, "r8gd.4xlarge"),
502            Self::R8gd_8xlarge => write!(f, "r8gd.8xlarge"),
503            Self::R8gd_12xlarge => write!(f, "r8gd.12xlarge"),
504            Self::R8gd_16xlarge => write!(f, "r8gd.16xlarge"),
505            Self::R8gd_24xlarge => write!(f, "r8gd.24xlarge"),
506            Self::R8gd_metal_24xl => write!(f, "r8gd.metal-24xl"),
507            Self::R8gd_48xlarge => write!(f, "r8gd.48xlarge"),
508            Self::R8gd_metal_48xl => write!(f, "r8gd.metal-48xl"),
509            Self::Unknown(s) => write!(f, "{s}"),
510        }
511    }
512}
513
514/// `pgStateProperty` enum from the ClickHouse Cloud API.
515#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
516pub enum PgStateProperty {
517    #[serde(rename = "creating")]
518    #[default]
519    Creating,
520    #[serde(rename = "restarting")]
521    Restarting,
522    #[serde(rename = "running")]
523    Running,
524    #[serde(rename = "replaying_wal")]
525    Replaying_wal,
526    #[serde(rename = "restoring_backup")]
527    Restoring_backup,
528    #[serde(rename = "finalizing_restore")]
529    Finalizing_restore,
530    #[serde(rename = "unavailable")]
531    Unavailable,
532    #[serde(rename = "deleting")]
533    Deleting,
534    /// Catch-all for unknown or newly-added values.
535    #[serde(untagged)]
536    Unknown(String),
537}
538
539impl std::fmt::Display for PgStateProperty {
540    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
541        match self {
542            Self::Creating => write!(f, "creating"),
543            Self::Restarting => write!(f, "restarting"),
544            Self::Running => write!(f, "running"),
545            Self::Replaying_wal => write!(f, "replaying_wal"),
546            Self::Restoring_backup => write!(f, "restoring_backup"),
547            Self::Finalizing_restore => write!(f, "finalizing_restore"),
548            Self::Unavailable => write!(f, "unavailable"),
549            Self::Deleting => write!(f, "deleting"),
550            Self::Unknown(s) => write!(f, "{s}"),
551        }
552    }
553}
554
555/// `pgVersion` enum from the ClickHouse Cloud API.
556#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
557pub enum PgVersion {
558    #[serde(rename = "18")]
559    #[default]
560    _18,
561    #[serde(rename = "17")]
562    _17,
563    /// Catch-all for unknown or newly-added values.
564    #[serde(untagged)]
565    Unknown(String),
566}
567
568impl std::fmt::Display for PgVersion {
569    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
570        match self {
571            Self::_18 => write!(f, "18"),
572            Self::_17 => write!(f, "17"),
573            Self::Unknown(s) => write!(f, "{s}"),
574        }
575    }
576}
577
578/// Inline enum for `Activity.actorType`.
579#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
580pub enum ActivityActortype {
581    #[serde(rename = "user")]
582    #[default]
583    User,
584    #[serde(rename = "support")]
585    Support,
586    #[serde(rename = "system")]
587    System,
588    #[serde(rename = "api")]
589    Api,
590    /// Catch-all for unknown or newly-added values.
591    #[serde(untagged)]
592    Unknown(String),
593}
594
595impl std::fmt::Display for ActivityActortype {
596    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
597        match self {
598            Self::User => write!(f, "user"),
599            Self::Support => write!(f, "support"),
600            Self::System => write!(f, "system"),
601            Self::Api => write!(f, "api"),
602            Self::Unknown(s) => write!(f, "{s}"),
603        }
604    }
605}
606
607/// Inline enum for `Activity.keyUpdateType`.
608#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
609pub enum ActivityKeyupdatetype {
610    #[serde(rename = "created")]
611    #[default]
612    Created,
613    #[serde(rename = "deleted")]
614    Deleted,
615    #[serde(rename = "name-changed")]
616    Name_changed,
617    #[serde(rename = "role-changed")]
618    Role_changed,
619    #[serde(rename = "state-changed")]
620    State_changed,
621    #[serde(rename = "date-changed")]
622    Date_changed,
623    #[serde(rename = "ip-access-list-changed")]
624    Ip_access_list_changed,
625    #[serde(rename = "org-role-changed")]
626    Org_role_changed,
627    #[serde(rename = "default-service-role-changed")]
628    Default_service_role_changed,
629    #[serde(rename = "service-role-changed")]
630    Service_role_changed,
631    #[serde(rename = "roles-v2-changed")]
632    Roles_v2_changed,
633    /// Catch-all for unknown or newly-added values.
634    #[serde(untagged)]
635    Unknown(String),
636}
637
638impl std::fmt::Display for ActivityKeyupdatetype {
639    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
640        match self {
641            Self::Created => write!(f, "created"),
642            Self::Deleted => write!(f, "deleted"),
643            Self::Name_changed => write!(f, "name-changed"),
644            Self::Role_changed => write!(f, "role-changed"),
645            Self::State_changed => write!(f, "state-changed"),
646            Self::Date_changed => write!(f, "date-changed"),
647            Self::Ip_access_list_changed => write!(f, "ip-access-list-changed"),
648            Self::Org_role_changed => write!(f, "org-role-changed"),
649            Self::Default_service_role_changed => write!(f, "default-service-role-changed"),
650            Self::Service_role_changed => write!(f, "service-role-changed"),
651            Self::Roles_v2_changed => write!(f, "roles-v2-changed"),
652            Self::Unknown(s) => write!(f, "{s}"),
653        }
654    }
655}
656
657/// Inline enum for `Activity.type`.
658#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
659pub enum ActivityType {
660    #[serde(rename = "create_organization")]
661    #[default]
662    Create_organization,
663    #[serde(rename = "organization_update_name")]
664    Organization_update_name,
665    #[serde(rename = "transfer_service_in")]
666    Transfer_service_in,
667    #[serde(rename = "transfer_service_out")]
668    Transfer_service_out,
669    #[serde(rename = "save_payment_method")]
670    Save_payment_method,
671    #[serde(rename = "marketplace_subscription")]
672    Marketplace_subscription,
673    #[serde(rename = "migrate_marketplace_billing_details_in")]
674    Migrate_marketplace_billing_details_in,
675    #[serde(rename = "migrate_marketplace_billing_details_out")]
676    Migrate_marketplace_billing_details_out,
677    #[serde(rename = "organization_update_tier")]
678    Organization_update_tier,
679    #[serde(rename = "organization_invite_create")]
680    Organization_invite_create,
681    #[serde(rename = "organization_invite_delete")]
682    Organization_invite_delete,
683    #[serde(rename = "organization_member_join")]
684    Organization_member_join,
685    #[serde(rename = "organization_member_add")]
686    Organization_member_add,
687    #[serde(rename = "organization_member_leave")]
688    Organization_member_leave,
689    #[serde(rename = "organization_member_delete")]
690    Organization_member_delete,
691    #[serde(rename = "organization_member_update_role")]
692    Organization_member_update_role,
693    #[serde(rename = "organization_member_update_mfa_method")]
694    Organization_member_update_mfa_method,
695    #[serde(rename = "user_login")]
696    User_login,
697    #[serde(rename = "user_login_failed")]
698    User_login_failed,
699    #[serde(rename = "user_logout")]
700    User_logout,
701    #[serde(rename = "key_create")]
702    Key_create,
703    #[serde(rename = "key_delete")]
704    Key_delete,
705    #[serde(rename = "openapi_key_update")]
706    Openapi_key_update,
707    #[serde(rename = "service_create")]
708    Service_create,
709    #[serde(rename = "service_start")]
710    Service_start,
711    #[serde(rename = "service_stop")]
712    Service_stop,
713    #[serde(rename = "service_awaken")]
714    Service_awaken,
715    #[serde(rename = "service_idle")]
716    Service_idle,
717    #[serde(rename = "service_running")]
718    Service_running,
719    #[serde(rename = "service_partially_running")]
720    Service_partially_running,
721    #[serde(rename = "service_delete")]
722    Service_delete,
723    #[serde(rename = "service_update_name")]
724    Service_update_name,
725    #[serde(rename = "service_update_ip_access_list")]
726    Service_update_ip_access_list,
727    #[serde(rename = "service_update_autoscaling_memory")]
728    Service_update_autoscaling_memory,
729    #[serde(rename = "service_update_autoscaling_idling")]
730    Service_update_autoscaling_idling,
731    #[serde(rename = "service_update_password")]
732    Service_update_password,
733    #[serde(rename = "service_update_autoscaling_replicas")]
734    Service_update_autoscaling_replicas,
735    #[serde(rename = "service_update_max_allowable_replicas")]
736    Service_update_max_allowable_replicas,
737    #[serde(rename = "service_update_backup_configuration")]
738    Service_update_backup_configuration,
739    #[serde(rename = "service_restore_backup")]
740    Service_restore_backup,
741    #[serde(rename = "service_update_release_channel")]
742    Service_update_release_channel,
743    #[serde(rename = "service_update_gpt_usage_consent")]
744    Service_update_gpt_usage_consent,
745    #[serde(rename = "service_update_private_endpoints")]
746    Service_update_private_endpoints,
747    #[serde(rename = "service_import_to_organization")]
748    Service_import_to_organization,
749    #[serde(rename = "service_export_from_organization")]
750    Service_export_from_organization,
751    #[serde(rename = "service_maintenance_start")]
752    Service_maintenance_start,
753    #[serde(rename = "service_maintenance_end")]
754    Service_maintenance_end,
755    #[serde(rename = "service_update_core_dump")]
756    Service_update_core_dump,
757    #[serde(rename = "backup_delete")]
758    Backup_delete,
759    /// Catch-all for unknown or newly-added values.
760    #[serde(untagged)]
761    Unknown(String),
762}
763
764impl std::fmt::Display for ActivityType {
765    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
766        match self {
767            Self::Create_organization => write!(f, "create_organization"),
768            Self::Organization_update_name => write!(f, "organization_update_name"),
769            Self::Transfer_service_in => write!(f, "transfer_service_in"),
770            Self::Transfer_service_out => write!(f, "transfer_service_out"),
771            Self::Save_payment_method => write!(f, "save_payment_method"),
772            Self::Marketplace_subscription => write!(f, "marketplace_subscription"),
773            Self::Migrate_marketplace_billing_details_in => write!(f, "migrate_marketplace_billing_details_in"),
774            Self::Migrate_marketplace_billing_details_out => write!(f, "migrate_marketplace_billing_details_out"),
775            Self::Organization_update_tier => write!(f, "organization_update_tier"),
776            Self::Organization_invite_create => write!(f, "organization_invite_create"),
777            Self::Organization_invite_delete => write!(f, "organization_invite_delete"),
778            Self::Organization_member_join => write!(f, "organization_member_join"),
779            Self::Organization_member_add => write!(f, "organization_member_add"),
780            Self::Organization_member_leave => write!(f, "organization_member_leave"),
781            Self::Organization_member_delete => write!(f, "organization_member_delete"),
782            Self::Organization_member_update_role => write!(f, "organization_member_update_role"),
783            Self::Organization_member_update_mfa_method => write!(f, "organization_member_update_mfa_method"),
784            Self::User_login => write!(f, "user_login"),
785            Self::User_login_failed => write!(f, "user_login_failed"),
786            Self::User_logout => write!(f, "user_logout"),
787            Self::Key_create => write!(f, "key_create"),
788            Self::Key_delete => write!(f, "key_delete"),
789            Self::Openapi_key_update => write!(f, "openapi_key_update"),
790            Self::Service_create => write!(f, "service_create"),
791            Self::Service_start => write!(f, "service_start"),
792            Self::Service_stop => write!(f, "service_stop"),
793            Self::Service_awaken => write!(f, "service_awaken"),
794            Self::Service_idle => write!(f, "service_idle"),
795            Self::Service_running => write!(f, "service_running"),
796            Self::Service_partially_running => write!(f, "service_partially_running"),
797            Self::Service_delete => write!(f, "service_delete"),
798            Self::Service_update_name => write!(f, "service_update_name"),
799            Self::Service_update_ip_access_list => write!(f, "service_update_ip_access_list"),
800            Self::Service_update_autoscaling_memory => write!(f, "service_update_autoscaling_memory"),
801            Self::Service_update_autoscaling_idling => write!(f, "service_update_autoscaling_idling"),
802            Self::Service_update_password => write!(f, "service_update_password"),
803            Self::Service_update_autoscaling_replicas => write!(f, "service_update_autoscaling_replicas"),
804            Self::Service_update_max_allowable_replicas => write!(f, "service_update_max_allowable_replicas"),
805            Self::Service_update_backup_configuration => write!(f, "service_update_backup_configuration"),
806            Self::Service_restore_backup => write!(f, "service_restore_backup"),
807            Self::Service_update_release_channel => write!(f, "service_update_release_channel"),
808            Self::Service_update_gpt_usage_consent => write!(f, "service_update_gpt_usage_consent"),
809            Self::Service_update_private_endpoints => write!(f, "service_update_private_endpoints"),
810            Self::Service_import_to_organization => write!(f, "service_import_to_organization"),
811            Self::Service_export_from_organization => write!(f, "service_export_from_organization"),
812            Self::Service_maintenance_start => write!(f, "service_maintenance_start"),
813            Self::Service_maintenance_end => write!(f, "service_maintenance_end"),
814            Self::Service_update_core_dump => write!(f, "service_update_core_dump"),
815            Self::Backup_delete => write!(f, "backup_delete"),
816            Self::Unknown(s) => write!(f, "{s}"),
817        }
818    }
819}
820
821/// Inline enum for `ApiKey.state`.
822#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
823pub enum ApiKeyState {
824    #[serde(rename = "enabled")]
825    #[default]
826    Enabled,
827    #[serde(rename = "disabled")]
828    Disabled,
829    /// Catch-all for unknown or newly-added values.
830    #[serde(untagged)]
831    Unknown(String),
832}
833
834impl std::fmt::Display for ApiKeyState {
835    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
836        match self {
837            Self::Enabled => write!(f, "enabled"),
838            Self::Disabled => write!(f, "disabled"),
839            Self::Unknown(s) => write!(f, "{s}"),
840        }
841    }
842}
843
844/// Inline enum for `ApiKeyPatchRequest.state`.
845#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
846pub enum ApiKeyPatchRequestState {
847    #[serde(rename = "enabled")]
848    #[default]
849    Enabled,
850    #[serde(rename = "disabled")]
851    Disabled,
852    /// Catch-all for unknown or newly-added values.
853    #[serde(untagged)]
854    Unknown(String),
855}
856
857impl std::fmt::Display for ApiKeyPatchRequestState {
858    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
859        match self {
860            Self::Enabled => write!(f, "enabled"),
861            Self::Disabled => write!(f, "disabled"),
862            Self::Unknown(s) => write!(f, "{s}"),
863        }
864    }
865}
866
867/// Inline enum for `ApiKeyPostRequest.state`.
868#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
869pub enum ApiKeyPostRequestState {
870    #[serde(rename = "enabled")]
871    #[default]
872    Enabled,
873    #[serde(rename = "disabled")]
874    Disabled,
875    /// Catch-all for unknown or newly-added values.
876    #[serde(untagged)]
877    Unknown(String),
878}
879
880impl std::fmt::Display for ApiKeyPostRequestState {
881    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
882        match self {
883            Self::Enabled => write!(f, "enabled"),
884            Self::Disabled => write!(f, "disabled"),
885            Self::Unknown(s) => write!(f, "{s}"),
886        }
887    }
888}
889
890/// Inline enum for `AssignedRole.roleType`.
891#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
892pub enum AssignedRoleRoletype {
893    #[serde(rename = "system")]
894    #[default]
895    System,
896    #[serde(rename = "custom")]
897    Custom,
898    /// Catch-all for unknown or newly-added values.
899    #[serde(untagged)]
900    Unknown(String),
901}
902
903impl std::fmt::Display for AssignedRoleRoletype {
904    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
905        match self {
906            Self::System => write!(f, "system"),
907            Self::Custom => write!(f, "custom"),
908            Self::Unknown(s) => write!(f, "{s}"),
909        }
910    }
911}
912
913/// Inline enum for `AwsBackupBucket.bucketProvider`.
914#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
915pub enum AwsBackupBucketBucketprovider {
916    #[default]
917    AWS,
918    /// Catch-all for unknown or newly-added values.
919    #[serde(untagged)]
920    Unknown(String),
921}
922
923impl std::fmt::Display for AwsBackupBucketBucketprovider {
924    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
925        match self {
926            Self::AWS => write!(f, "AWS"),
927            Self::Unknown(s) => write!(f, "{s}"),
928        }
929    }
930}
931
932/// Inline enum for `AwsBackupBucketPatchRequestV1.bucketProvider`.
933#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
934pub enum AwsBackupBucketPatchRequestV1Bucketprovider {
935    #[default]
936    AWS,
937    /// Catch-all for unknown or newly-added values.
938    #[serde(untagged)]
939    Unknown(String),
940}
941
942impl std::fmt::Display for AwsBackupBucketPatchRequestV1Bucketprovider {
943    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
944        match self {
945            Self::AWS => write!(f, "AWS"),
946            Self::Unknown(s) => write!(f, "{s}"),
947        }
948    }
949}
950
951/// Inline enum for `AwsBackupBucketPostRequestV1.bucketProvider`.
952#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
953pub enum AwsBackupBucketPostRequestV1Bucketprovider {
954    #[default]
955    AWS,
956    /// Catch-all for unknown or newly-added values.
957    #[serde(untagged)]
958    Unknown(String),
959}
960
961impl std::fmt::Display for AwsBackupBucketPostRequestV1Bucketprovider {
962    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
963        match self {
964            Self::AWS => write!(f, "AWS"),
965            Self::Unknown(s) => write!(f, "{s}"),
966        }
967    }
968}
969
970/// Inline enum for `AwsBackupBucketProperties.bucketProvider`.
971#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
972pub enum AwsBackupBucketPropertiesBucketprovider {
973    #[default]
974    AWS,
975    /// Catch-all for unknown or newly-added values.
976    #[serde(untagged)]
977    Unknown(String),
978}
979
980impl std::fmt::Display for AwsBackupBucketPropertiesBucketprovider {
981    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
982        match self {
983            Self::AWS => write!(f, "AWS"),
984            Self::Unknown(s) => write!(f, "{s}"),
985        }
986    }
987}
988
989/// Inline enum for `AzureBackupBucket.bucketProvider`.
990#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
991pub enum AzureBackupBucketBucketprovider {
992    #[default]
993    AZURE,
994    /// Catch-all for unknown or newly-added values.
995    #[serde(untagged)]
996    Unknown(String),
997}
998
999impl std::fmt::Display for AzureBackupBucketBucketprovider {
1000    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1001        match self {
1002            Self::AZURE => write!(f, "AZURE"),
1003            Self::Unknown(s) => write!(f, "{s}"),
1004        }
1005    }
1006}
1007
1008/// Inline enum for `AzureBackupBucketPatchRequestV1.bucketProvider`.
1009#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1010pub enum AzureBackupBucketPatchRequestV1Bucketprovider {
1011    #[default]
1012    AZURE,
1013    /// Catch-all for unknown or newly-added values.
1014    #[serde(untagged)]
1015    Unknown(String),
1016}
1017
1018impl std::fmt::Display for AzureBackupBucketPatchRequestV1Bucketprovider {
1019    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1020        match self {
1021            Self::AZURE => write!(f, "AZURE"),
1022            Self::Unknown(s) => write!(f, "{s}"),
1023        }
1024    }
1025}
1026
1027/// Inline enum for `AzureBackupBucketPostRequestV1.bucketProvider`.
1028#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1029pub enum AzureBackupBucketPostRequestV1Bucketprovider {
1030    #[default]
1031    AZURE,
1032    /// Catch-all for unknown or newly-added values.
1033    #[serde(untagged)]
1034    Unknown(String),
1035}
1036
1037impl std::fmt::Display for AzureBackupBucketPostRequestV1Bucketprovider {
1038    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1039        match self {
1040            Self::AZURE => write!(f, "AZURE"),
1041            Self::Unknown(s) => write!(f, "{s}"),
1042        }
1043    }
1044}
1045
1046/// Inline enum for `AzureBackupBucketProperties.bucketProvider`.
1047#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1048pub enum AzureBackupBucketPropertiesBucketprovider {
1049    #[default]
1050    AZURE,
1051    /// Catch-all for unknown or newly-added values.
1052    #[serde(untagged)]
1053    Unknown(String),
1054}
1055
1056impl std::fmt::Display for AzureBackupBucketPropertiesBucketprovider {
1057    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1058        match self {
1059            Self::AZURE => write!(f, "AZURE"),
1060            Self::Unknown(s) => write!(f, "{s}"),
1061        }
1062    }
1063}
1064
1065/// Inline enum for `Backup.status`.
1066#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1067pub enum BackupStatus {
1068    #[serde(rename = "done")]
1069    #[default]
1070    Done,
1071    #[serde(rename = "error")]
1072    Error,
1073    #[serde(rename = "in_progress")]
1074    In_progress,
1075    /// Catch-all for unknown or newly-added values.
1076    #[serde(untagged)]
1077    Unknown(String),
1078}
1079
1080impl std::fmt::Display for BackupStatus {
1081    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1082        match self {
1083            Self::Done => write!(f, "done"),
1084            Self::Error => write!(f, "error"),
1085            Self::In_progress => write!(f, "in_progress"),
1086            Self::Unknown(s) => write!(f, "{s}"),
1087        }
1088    }
1089}
1090
1091/// Inline enum for `Backup.type`.
1092#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1093pub enum BackupType {
1094    #[serde(rename = "full")]
1095    #[default]
1096    Full,
1097    #[serde(rename = "incremental")]
1098    Incremental,
1099    /// Catch-all for unknown or newly-added values.
1100    #[serde(untagged)]
1101    Unknown(String),
1102}
1103
1104impl std::fmt::Display for BackupType {
1105    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1106        match self {
1107            Self::Full => write!(f, "full"),
1108            Self::Incremental => write!(f, "incremental"),
1109            Self::Unknown(s) => write!(f, "{s}"),
1110        }
1111    }
1112}
1113
1114/// Inline enum for `ByocConfig.cloudProvider`.
1115#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1116pub enum ByocConfigCloudprovider {
1117    #[serde(rename = "gcp")]
1118    #[default]
1119    Gcp,
1120    #[serde(rename = "aws")]
1121    Aws,
1122    #[serde(rename = "azure")]
1123    Azure,
1124    /// Catch-all for unknown or newly-added values.
1125    #[serde(untagged)]
1126    Unknown(String),
1127}
1128
1129impl std::fmt::Display for ByocConfigCloudprovider {
1130    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1131        match self {
1132            Self::Gcp => write!(f, "gcp"),
1133            Self::Aws => write!(f, "aws"),
1134            Self::Azure => write!(f, "azure"),
1135            Self::Unknown(s) => write!(f, "{s}"),
1136        }
1137    }
1138}
1139
1140/// Inline enum for `ByocConfig.regionId`.
1141#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1142pub enum ByocConfigRegionid {
1143    #[serde(rename = "ap-northeast-1")]
1144    #[default]
1145    Ap_northeast_1,
1146    #[serde(rename = "ap-northeast-2")]
1147    Ap_northeast_2,
1148    #[serde(rename = "ap-south-1")]
1149    Ap_south_1,
1150    #[serde(rename = "ap-southeast-1")]
1151    Ap_southeast_1,
1152    #[serde(rename = "ap-southeast-2")]
1153    Ap_southeast_2,
1154    #[serde(rename = "eu-central-1")]
1155    Eu_central_1,
1156    #[serde(rename = "eu-west-1")]
1157    Eu_west_1,
1158    #[serde(rename = "eu-west-2")]
1159    Eu_west_2,
1160    #[serde(rename = "il-central-1")]
1161    Il_central_1,
1162    #[serde(rename = "us-east-1")]
1163    Us_east_1,
1164    #[serde(rename = "us-east-2")]
1165    Us_east_2,
1166    #[serde(rename = "us-west-2")]
1167    Us_west_2,
1168    #[serde(rename = "us-east1")]
1169    Us_east1,
1170    #[serde(rename = "us-central1")]
1171    Us_central1,
1172    #[serde(rename = "europe-west4")]
1173    Europe_west4,
1174    #[serde(rename = "asia-southeast1")]
1175    Asia_southeast1,
1176    #[serde(rename = "asia-northeast1")]
1177    Asia_northeast1,
1178    #[serde(rename = "eastus")]
1179    Eastus,
1180    #[serde(rename = "eastus2")]
1181    Eastus2,
1182    #[serde(rename = "westus3")]
1183    Westus3,
1184    #[serde(rename = "germanywestcentral")]
1185    Germanywestcentral,
1186    #[serde(rename = "centralus")]
1187    Centralus,
1188    /// Catch-all for unknown or newly-added values.
1189    #[serde(untagged)]
1190    Unknown(String),
1191}
1192
1193impl std::fmt::Display for ByocConfigRegionid {
1194    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1195        match self {
1196            Self::Ap_northeast_1 => write!(f, "ap-northeast-1"),
1197            Self::Ap_northeast_2 => write!(f, "ap-northeast-2"),
1198            Self::Ap_south_1 => write!(f, "ap-south-1"),
1199            Self::Ap_southeast_1 => write!(f, "ap-southeast-1"),
1200            Self::Ap_southeast_2 => write!(f, "ap-southeast-2"),
1201            Self::Eu_central_1 => write!(f, "eu-central-1"),
1202            Self::Eu_west_1 => write!(f, "eu-west-1"),
1203            Self::Eu_west_2 => write!(f, "eu-west-2"),
1204            Self::Il_central_1 => write!(f, "il-central-1"),
1205            Self::Us_east_1 => write!(f, "us-east-1"),
1206            Self::Us_east_2 => write!(f, "us-east-2"),
1207            Self::Us_west_2 => write!(f, "us-west-2"),
1208            Self::Us_east1 => write!(f, "us-east1"),
1209            Self::Us_central1 => write!(f, "us-central1"),
1210            Self::Europe_west4 => write!(f, "europe-west4"),
1211            Self::Asia_southeast1 => write!(f, "asia-southeast1"),
1212            Self::Asia_northeast1 => write!(f, "asia-northeast1"),
1213            Self::Eastus => write!(f, "eastus"),
1214            Self::Eastus2 => write!(f, "eastus2"),
1215            Self::Westus3 => write!(f, "westus3"),
1216            Self::Germanywestcentral => write!(f, "germanywestcentral"),
1217            Self::Centralus => write!(f, "centralus"),
1218            Self::Unknown(s) => write!(f, "{s}"),
1219        }
1220    }
1221}
1222
1223/// Inline enum for `ByocConfig.state`.
1224#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1225pub enum ByocConfigState {
1226    #[serde(rename = "infra-ready")]
1227    #[default]
1228    Infra_ready,
1229    #[serde(rename = "infra-provisioning")]
1230    Infra_provisioning,
1231    #[serde(rename = "infra-terminated")]
1232    Infra_terminated,
1233    /// Catch-all for unknown or newly-added values.
1234    #[serde(untagged)]
1235    Unknown(String),
1236}
1237
1238impl std::fmt::Display for ByocConfigState {
1239    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1240        match self {
1241            Self::Infra_ready => write!(f, "infra-ready"),
1242            Self::Infra_provisioning => write!(f, "infra-provisioning"),
1243            Self::Infra_terminated => write!(f, "infra-terminated"),
1244            Self::Unknown(s) => write!(f, "{s}"),
1245        }
1246    }
1247}
1248
1249/// Inline enum for `ByocInfrastructurePostRequest.regionId`.
1250#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1251pub enum ByocInfrastructurePostRequestRegionid {
1252    #[serde(rename = "ap-northeast-1")]
1253    #[default]
1254    Ap_northeast_1,
1255    #[serde(rename = "ap-northeast-2")]
1256    Ap_northeast_2,
1257    #[serde(rename = "ap-south-1")]
1258    Ap_south_1,
1259    #[serde(rename = "ap-southeast-1")]
1260    Ap_southeast_1,
1261    #[serde(rename = "ap-southeast-2")]
1262    Ap_southeast_2,
1263    #[serde(rename = "eu-central-1")]
1264    Eu_central_1,
1265    #[serde(rename = "eu-west-1")]
1266    Eu_west_1,
1267    #[serde(rename = "eu-west-2")]
1268    Eu_west_2,
1269    #[serde(rename = "il-central-1")]
1270    Il_central_1,
1271    #[serde(rename = "us-east-1")]
1272    Us_east_1,
1273    #[serde(rename = "us-east-2")]
1274    Us_east_2,
1275    #[serde(rename = "us-west-2")]
1276    Us_west_2,
1277    #[serde(rename = "us-east1")]
1278    Us_east1,
1279    #[serde(rename = "us-central1")]
1280    Us_central1,
1281    #[serde(rename = "europe-west4")]
1282    Europe_west4,
1283    #[serde(rename = "asia-southeast1")]
1284    Asia_southeast1,
1285    #[serde(rename = "asia-northeast1")]
1286    Asia_northeast1,
1287    #[serde(rename = "eastus")]
1288    Eastus,
1289    #[serde(rename = "eastus2")]
1290    Eastus2,
1291    #[serde(rename = "westus3")]
1292    Westus3,
1293    #[serde(rename = "germanywestcentral")]
1294    Germanywestcentral,
1295    #[serde(rename = "centralus")]
1296    Centralus,
1297    /// Catch-all for unknown or newly-added values.
1298    #[serde(untagged)]
1299    Unknown(String),
1300}
1301
1302impl std::fmt::Display for ByocInfrastructurePostRequestRegionid {
1303    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1304        match self {
1305            Self::Ap_northeast_1 => write!(f, "ap-northeast-1"),
1306            Self::Ap_northeast_2 => write!(f, "ap-northeast-2"),
1307            Self::Ap_south_1 => write!(f, "ap-south-1"),
1308            Self::Ap_southeast_1 => write!(f, "ap-southeast-1"),
1309            Self::Ap_southeast_2 => write!(f, "ap-southeast-2"),
1310            Self::Eu_central_1 => write!(f, "eu-central-1"),
1311            Self::Eu_west_1 => write!(f, "eu-west-1"),
1312            Self::Eu_west_2 => write!(f, "eu-west-2"),
1313            Self::Il_central_1 => write!(f, "il-central-1"),
1314            Self::Us_east_1 => write!(f, "us-east-1"),
1315            Self::Us_east_2 => write!(f, "us-east-2"),
1316            Self::Us_west_2 => write!(f, "us-west-2"),
1317            Self::Us_east1 => write!(f, "us-east1"),
1318            Self::Us_central1 => write!(f, "us-central1"),
1319            Self::Europe_west4 => write!(f, "europe-west4"),
1320            Self::Asia_southeast1 => write!(f, "asia-southeast1"),
1321            Self::Asia_northeast1 => write!(f, "asia-northeast1"),
1322            Self::Eastus => write!(f, "eastus"),
1323            Self::Eastus2 => write!(f, "eastus2"),
1324            Self::Westus3 => write!(f, "westus3"),
1325            Self::Germanywestcentral => write!(f, "germanywestcentral"),
1326            Self::Centralus => write!(f, "centralus"),
1327            Self::Unknown(s) => write!(f, "{s}"),
1328        }
1329    }
1330}
1331
1332/// Inline enum for `ClickPipe.state`.
1333#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1334pub enum ClickPipeState {
1335    #[default]
1336    Unknown,
1337    Provisioning,
1338    Running,
1339    Stopping,
1340    Stopped,
1341    Failed,
1342    Completed,
1343    InternalError,
1344    Setup,
1345    Snapshot,
1346    Paused,
1347    Pausing,
1348    Modifying,
1349    Resync,
1350    /// Catch-all for unknown or newly-added values.
1351    #[serde(untagged)]
1352    Other(String),
1353}
1354
1355impl std::fmt::Display for ClickPipeState {
1356    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1357        match self {
1358            Self::Unknown => write!(f, "Unknown"),
1359            Self::Provisioning => write!(f, "Provisioning"),
1360            Self::Running => write!(f, "Running"),
1361            Self::Stopping => write!(f, "Stopping"),
1362            Self::Stopped => write!(f, "Stopped"),
1363            Self::Failed => write!(f, "Failed"),
1364            Self::Completed => write!(f, "Completed"),
1365            Self::InternalError => write!(f, "InternalError"),
1366            Self::Setup => write!(f, "Setup"),
1367            Self::Snapshot => write!(f, "Snapshot"),
1368            Self::Paused => write!(f, "Paused"),
1369            Self::Pausing => write!(f, "Pausing"),
1370            Self::Modifying => write!(f, "Modifying"),
1371            Self::Resync => write!(f, "Resync"),
1372            Self::Other(s) => write!(f, "{s}"),
1373        }
1374    }
1375}
1376
1377/// Inline enum for `ClickPipeBigQueryPipeSettings.replicationMode`.
1378#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1379pub enum ClickPipeBigQueryPipeSettingsReplicationmode {
1380    #[serde(rename = "snapshot")]
1381    #[default]
1382    Snapshot,
1383    /// Catch-all for unknown or newly-added values.
1384    #[serde(untagged)]
1385    Unknown(String),
1386}
1387
1388impl std::fmt::Display for ClickPipeBigQueryPipeSettingsReplicationmode {
1389    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1390        match self {
1391            Self::Snapshot => write!(f, "snapshot"),
1392            Self::Unknown(s) => write!(f, "{s}"),
1393        }
1394    }
1395}
1396
1397/// Inline enum for `ClickPipeBigQueryPipeTableMapping.tableEngine`.
1398#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1399pub enum ClickPipeBigQueryPipeTableMappingTableengine {
1400    #[default]
1401    MergeTree,
1402    ReplacingMergeTree,
1403    Null,
1404    /// Catch-all for unknown or newly-added values.
1405    #[serde(untagged)]
1406    Unknown(String),
1407}
1408
1409impl std::fmt::Display for ClickPipeBigQueryPipeTableMappingTableengine {
1410    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1411        match self {
1412            Self::MergeTree => write!(f, "MergeTree"),
1413            Self::ReplacingMergeTree => write!(f, "ReplacingMergeTree"),
1414            Self::Null => write!(f, "Null"),
1415            Self::Unknown(s) => write!(f, "{s}"),
1416        }
1417    }
1418}
1419
1420/// Inline enum for `ClickPipeDestinationTableEngine.type`.
1421#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1422pub enum ClickPipeDestinationTableEngineType {
1423    #[default]
1424    MergeTree,
1425    ReplacingMergeTree,
1426    SummingMergeTree,
1427    Null,
1428    /// Catch-all for unknown or newly-added values.
1429    #[serde(untagged)]
1430    Unknown(String),
1431}
1432
1433impl std::fmt::Display for ClickPipeDestinationTableEngineType {
1434    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1435        match self {
1436            Self::MergeTree => write!(f, "MergeTree"),
1437            Self::ReplacingMergeTree => write!(f, "ReplacingMergeTree"),
1438            Self::SummingMergeTree => write!(f, "SummingMergeTree"),
1439            Self::Null => write!(f, "Null"),
1440            Self::Unknown(s) => write!(f, "{s}"),
1441        }
1442    }
1443}
1444
1445/// Inline enum for `ClickPipeKafkaOffset.strategy`.
1446#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1447pub enum ClickPipeKafkaOffsetStrategy {
1448    #[serde(rename = "from_beginning")]
1449    #[default]
1450    From_beginning,
1451    #[serde(rename = "from_latest")]
1452    From_latest,
1453    #[serde(rename = "from_timestamp")]
1454    From_timestamp,
1455    /// Catch-all for unknown or newly-added values.
1456    #[serde(untagged)]
1457    Unknown(String),
1458}
1459
1460impl std::fmt::Display for ClickPipeKafkaOffsetStrategy {
1461    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1462        match self {
1463            Self::From_beginning => write!(f, "from_beginning"),
1464            Self::From_latest => write!(f, "from_latest"),
1465            Self::From_timestamp => write!(f, "from_timestamp"),
1466            Self::Unknown(s) => write!(f, "{s}"),
1467        }
1468    }
1469}
1470
1471/// Inline enum for `ClickPipeKafkaSchemaRegistry.authentication`.
1472#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1473pub enum ClickPipeKafkaSchemaRegistryAuthentication {
1474    #[default]
1475    PLAIN,
1476    /// Catch-all for unknown or newly-added values.
1477    #[serde(untagged)]
1478    Unknown(String),
1479}
1480
1481impl std::fmt::Display for ClickPipeKafkaSchemaRegistryAuthentication {
1482    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1483        match self {
1484            Self::PLAIN => write!(f, "PLAIN"),
1485            Self::Unknown(s) => write!(f, "{s}"),
1486        }
1487    }
1488}
1489
1490/// Inline enum for `ClickPipeKafkaSource.authentication`.
1491#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1492pub enum ClickPipeKafkaSourceAuthentication {
1493    #[default]
1494    PLAIN,
1495    #[serde(rename = "SCRAM-SHA-256")]
1496    SCRAM_SHA_256,
1497    #[serde(rename = "SCRAM-SHA-512")]
1498    SCRAM_SHA_512,
1499    IAM_ROLE,
1500    IAM_USER,
1501    MUTUAL_TLS,
1502    /// Catch-all for unknown or newly-added values.
1503    #[serde(untagged)]
1504    Unknown(String),
1505}
1506
1507impl std::fmt::Display for ClickPipeKafkaSourceAuthentication {
1508    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1509        match self {
1510            Self::PLAIN => write!(f, "PLAIN"),
1511            Self::SCRAM_SHA_256 => write!(f, "SCRAM-SHA-256"),
1512            Self::SCRAM_SHA_512 => write!(f, "SCRAM-SHA-512"),
1513            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
1514            Self::IAM_USER => write!(f, "IAM_USER"),
1515            Self::MUTUAL_TLS => write!(f, "MUTUAL_TLS"),
1516            Self::Unknown(s) => write!(f, "{s}"),
1517        }
1518    }
1519}
1520
1521/// Inline enum for `ClickPipeKafkaSource.format`.
1522#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1523pub enum ClickPipeKafkaSourceFormat {
1524    #[default]
1525    JSONEachRow,
1526    Avro,
1527    AvroConfluent,
1528    Protobuf,
1529    /// Catch-all for unknown or newly-added values.
1530    #[serde(untagged)]
1531    Unknown(String),
1532}
1533
1534impl std::fmt::Display for ClickPipeKafkaSourceFormat {
1535    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1536        match self {
1537            Self::JSONEachRow => write!(f, "JSONEachRow"),
1538            Self::Avro => write!(f, "Avro"),
1539            Self::AvroConfluent => write!(f, "AvroConfluent"),
1540            Self::Protobuf => write!(f, "Protobuf"),
1541            Self::Unknown(s) => write!(f, "{s}"),
1542        }
1543    }
1544}
1545
1546/// Inline enum for `ClickPipeKafkaSource.type`.
1547#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1548pub enum ClickPipeKafkaSourceType {
1549    #[serde(rename = "kafka")]
1550    #[default]
1551    Kafka,
1552    #[serde(rename = "redpanda")]
1553    Redpanda,
1554    #[serde(rename = "msk")]
1555    Msk,
1556    #[serde(rename = "gcmk")]
1557    Gcmk,
1558    #[serde(rename = "confluent")]
1559    Confluent,
1560    #[serde(rename = "warpstream")]
1561    Warpstream,
1562    #[serde(rename = "azureeventhub")]
1563    Azureeventhub,
1564    #[serde(rename = "dokafka")]
1565    Dokafka,
1566    /// Catch-all for unknown or newly-added values.
1567    #[serde(untagged)]
1568    Unknown(String),
1569}
1570
1571impl std::fmt::Display for ClickPipeKafkaSourceType {
1572    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1573        match self {
1574            Self::Kafka => write!(f, "kafka"),
1575            Self::Redpanda => write!(f, "redpanda"),
1576            Self::Msk => write!(f, "msk"),
1577            Self::Gcmk => write!(f, "gcmk"),
1578            Self::Confluent => write!(f, "confluent"),
1579            Self::Warpstream => write!(f, "warpstream"),
1580            Self::Azureeventhub => write!(f, "azureeventhub"),
1581            Self::Dokafka => write!(f, "dokafka"),
1582            Self::Unknown(s) => write!(f, "{s}"),
1583        }
1584    }
1585}
1586
1587/// Inline enum for `ClickPipeKinesisSource.authentication`.
1588#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1589pub enum ClickPipeKinesisSourceAuthentication {
1590    #[default]
1591    IAM_ROLE,
1592    IAM_USER,
1593    /// Catch-all for unknown or newly-added values.
1594    #[serde(untagged)]
1595    Unknown(String),
1596}
1597
1598impl std::fmt::Display for ClickPipeKinesisSourceAuthentication {
1599    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1600        match self {
1601            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
1602            Self::IAM_USER => write!(f, "IAM_USER"),
1603            Self::Unknown(s) => write!(f, "{s}"),
1604        }
1605    }
1606}
1607
1608/// Inline enum for `ClickPipeKinesisSource.format`.
1609#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1610pub enum ClickPipeKinesisSourceFormat {
1611    #[default]
1612    JSONEachRow,
1613    Avro,
1614    AvroConfluent,
1615    /// Catch-all for unknown or newly-added values.
1616    #[serde(untagged)]
1617    Unknown(String),
1618}
1619
1620impl std::fmt::Display for ClickPipeKinesisSourceFormat {
1621    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1622        match self {
1623            Self::JSONEachRow => write!(f, "JSONEachRow"),
1624            Self::Avro => write!(f, "Avro"),
1625            Self::AvroConfluent => write!(f, "AvroConfluent"),
1626            Self::Unknown(s) => write!(f, "{s}"),
1627        }
1628    }
1629}
1630
1631/// Inline enum for `ClickPipeKinesisSource.iteratorType`.
1632#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1633pub enum ClickPipeKinesisSourceIteratortype {
1634    #[default]
1635    TRIM_HORIZON,
1636    LATEST,
1637    AT_TIMESTAMP,
1638    /// Catch-all for unknown or newly-added values.
1639    #[serde(untagged)]
1640    Unknown(String),
1641}
1642
1643impl std::fmt::Display for ClickPipeKinesisSourceIteratortype {
1644    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1645        match self {
1646            Self::TRIM_HORIZON => write!(f, "TRIM_HORIZON"),
1647            Self::LATEST => write!(f, "LATEST"),
1648            Self::AT_TIMESTAMP => write!(f, "AT_TIMESTAMP"),
1649            Self::Unknown(s) => write!(f, "{s}"),
1650        }
1651    }
1652}
1653
1654/// Inline enum for `ClickPipeMongoDBPipeSettings.replicationMode`.
1655#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1656pub enum ClickPipeMongoDBPipeSettingsReplicationmode {
1657    #[serde(rename = "cdc")]
1658    #[default]
1659    Cdc,
1660    #[serde(rename = "snapshot")]
1661    Snapshot,
1662    #[serde(rename = "cdc_only")]
1663    Cdc_only,
1664    /// Catch-all for unknown or newly-added values.
1665    #[serde(untagged)]
1666    Unknown(String),
1667}
1668
1669impl std::fmt::Display for ClickPipeMongoDBPipeSettingsReplicationmode {
1670    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1671        match self {
1672            Self::Cdc => write!(f, "cdc"),
1673            Self::Snapshot => write!(f, "snapshot"),
1674            Self::Cdc_only => write!(f, "cdc_only"),
1675            Self::Unknown(s) => write!(f, "{s}"),
1676        }
1677    }
1678}
1679
1680/// Inline enum for `ClickPipeMongoDBPipeTableMapping.tableEngine`.
1681#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1682pub enum ClickPipeMongoDBPipeTableMappingTableengine {
1683    #[default]
1684    MergeTree,
1685    ReplacingMergeTree,
1686    Null,
1687    /// Catch-all for unknown or newly-added values.
1688    #[serde(untagged)]
1689    Unknown(String),
1690}
1691
1692impl std::fmt::Display for ClickPipeMongoDBPipeTableMappingTableengine {
1693    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1694        match self {
1695            Self::MergeTree => write!(f, "MergeTree"),
1696            Self::ReplacingMergeTree => write!(f, "ReplacingMergeTree"),
1697            Self::Null => write!(f, "Null"),
1698            Self::Unknown(s) => write!(f, "{s}"),
1699        }
1700    }
1701}
1702
1703/// Inline enum for `ClickPipeMongoDBSource.readPreference`.
1704#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1705pub enum ClickPipeMongoDBSourceReadpreference {
1706    #[serde(rename = "primary")]
1707    #[default]
1708    Primary,
1709    #[serde(rename = "primaryPreferred")]
1710    PrimaryPreferred,
1711    #[serde(rename = "secondary")]
1712    Secondary,
1713    #[serde(rename = "secondaryPreferred")]
1714    SecondaryPreferred,
1715    #[serde(rename = "nearest")]
1716    Nearest,
1717    /// Catch-all for unknown or newly-added values.
1718    #[serde(untagged)]
1719    Unknown(String),
1720}
1721
1722impl std::fmt::Display for ClickPipeMongoDBSourceReadpreference {
1723    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1724        match self {
1725            Self::Primary => write!(f, "primary"),
1726            Self::PrimaryPreferred => write!(f, "primaryPreferred"),
1727            Self::Secondary => write!(f, "secondary"),
1728            Self::SecondaryPreferred => write!(f, "secondaryPreferred"),
1729            Self::Nearest => write!(f, "nearest"),
1730            Self::Unknown(s) => write!(f, "{s}"),
1731        }
1732    }
1733}
1734
1735/// Inline enum for `ClickPipeMutateKafkaSchemaRegistry.authentication`.
1736#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1737pub enum ClickPipeMutateKafkaSchemaRegistryAuthentication {
1738    #[default]
1739    PLAIN,
1740    /// Catch-all for unknown or newly-added values.
1741    #[serde(untagged)]
1742    Unknown(String),
1743}
1744
1745impl std::fmt::Display for ClickPipeMutateKafkaSchemaRegistryAuthentication {
1746    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1747        match self {
1748            Self::PLAIN => write!(f, "PLAIN"),
1749            Self::Unknown(s) => write!(f, "{s}"),
1750        }
1751    }
1752}
1753
1754/// Inline enum for `ClickPipeMutateMongoDBSource.readPreference`.
1755#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1756pub enum ClickPipeMutateMongoDBSourceReadpreference {
1757    #[serde(rename = "primary")]
1758    #[default]
1759    Primary,
1760    #[serde(rename = "primaryPreferred")]
1761    PrimaryPreferred,
1762    #[serde(rename = "secondary")]
1763    Secondary,
1764    #[serde(rename = "secondaryPreferred")]
1765    SecondaryPreferred,
1766    #[serde(rename = "nearest")]
1767    Nearest,
1768    /// Catch-all for unknown or newly-added values.
1769    #[serde(untagged)]
1770    Unknown(String),
1771}
1772
1773impl std::fmt::Display for ClickPipeMutateMongoDBSourceReadpreference {
1774    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1775        match self {
1776            Self::Primary => write!(f, "primary"),
1777            Self::PrimaryPreferred => write!(f, "primaryPreferred"),
1778            Self::Secondary => write!(f, "secondary"),
1779            Self::SecondaryPreferred => write!(f, "secondaryPreferred"),
1780            Self::Nearest => write!(f, "nearest"),
1781            Self::Unknown(s) => write!(f, "{s}"),
1782        }
1783    }
1784}
1785
1786/// Inline enum for `ClickPipeMutateMySQLSource.authentication`.
1787#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1788pub enum ClickPipeMutateMySQLSourceAuthentication {
1789    #[serde(rename = "basic")]
1790    #[default]
1791    Basic,
1792    IAM_ROLE,
1793    /// Catch-all for unknown or newly-added values.
1794    #[serde(untagged)]
1795    Unknown(String),
1796}
1797
1798impl std::fmt::Display for ClickPipeMutateMySQLSourceAuthentication {
1799    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1800        match self {
1801            Self::Basic => write!(f, "basic"),
1802            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
1803            Self::Unknown(s) => write!(f, "{s}"),
1804        }
1805    }
1806}
1807
1808/// Inline enum for `ClickPipeMutateMySQLSource.type`.
1809#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1810pub enum ClickPipeMutateMySQLSourceType {
1811    #[serde(rename = "mysql")]
1812    #[default]
1813    Mysql,
1814    #[serde(rename = "rdsmysql")]
1815    Rdsmysql,
1816    #[serde(rename = "auroramysql")]
1817    Auroramysql,
1818    #[serde(rename = "mariadb")]
1819    Mariadb,
1820    #[serde(rename = "rdsmariadb")]
1821    Rdsmariadb,
1822    /// Catch-all for unknown or newly-added values.
1823    #[serde(untagged)]
1824    Unknown(String),
1825}
1826
1827impl std::fmt::Display for ClickPipeMutateMySQLSourceType {
1828    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1829        match self {
1830            Self::Mysql => write!(f, "mysql"),
1831            Self::Rdsmysql => write!(f, "rdsmysql"),
1832            Self::Auroramysql => write!(f, "auroramysql"),
1833            Self::Mariadb => write!(f, "mariadb"),
1834            Self::Rdsmariadb => write!(f, "rdsmariadb"),
1835            Self::Unknown(s) => write!(f, "{s}"),
1836        }
1837    }
1838}
1839
1840/// Inline enum for `ClickPipeMutatePostgresSource.authentication`.
1841#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1842pub enum ClickPipeMutatePostgresSourceAuthentication {
1843    #[serde(rename = "basic")]
1844    #[default]
1845    Basic,
1846    IAM_ROLE,
1847    /// Catch-all for unknown or newly-added values.
1848    #[serde(untagged)]
1849    Unknown(String),
1850}
1851
1852impl std::fmt::Display for ClickPipeMutatePostgresSourceAuthentication {
1853    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1854        match self {
1855            Self::Basic => write!(f, "basic"),
1856            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
1857            Self::Unknown(s) => write!(f, "{s}"),
1858        }
1859    }
1860}
1861
1862/// Inline enum for `ClickPipeMutatePostgresSource.type`.
1863#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1864pub enum ClickPipeMutatePostgresSourceType {
1865    #[serde(rename = "postgres")]
1866    #[default]
1867    Postgres,
1868    #[serde(rename = "supabase")]
1869    Supabase,
1870    #[serde(rename = "neon")]
1871    Neon,
1872    #[serde(rename = "alloydb")]
1873    Alloydb,
1874    #[serde(rename = "planetscale")]
1875    Planetscale,
1876    #[serde(rename = "rdspostgres")]
1877    Rdspostgres,
1878    #[serde(rename = "aurorapostgres")]
1879    Aurorapostgres,
1880    #[serde(rename = "cloudsqlpostgres")]
1881    Cloudsqlpostgres,
1882    #[serde(rename = "azurepostgres")]
1883    Azurepostgres,
1884    #[serde(rename = "crunchybridge")]
1885    Crunchybridge,
1886    #[serde(rename = "tigerdata")]
1887    Tigerdata,
1888    /// Catch-all for unknown or newly-added values.
1889    #[serde(untagged)]
1890    Unknown(String),
1891}
1892
1893impl std::fmt::Display for ClickPipeMutatePostgresSourceType {
1894    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1895        match self {
1896            Self::Postgres => write!(f, "postgres"),
1897            Self::Supabase => write!(f, "supabase"),
1898            Self::Neon => write!(f, "neon"),
1899            Self::Alloydb => write!(f, "alloydb"),
1900            Self::Planetscale => write!(f, "planetscale"),
1901            Self::Rdspostgres => write!(f, "rdspostgres"),
1902            Self::Aurorapostgres => write!(f, "aurorapostgres"),
1903            Self::Cloudsqlpostgres => write!(f, "cloudsqlpostgres"),
1904            Self::Azurepostgres => write!(f, "azurepostgres"),
1905            Self::Crunchybridge => write!(f, "crunchybridge"),
1906            Self::Tigerdata => write!(f, "tigerdata"),
1907            Self::Unknown(s) => write!(f, "{s}"),
1908        }
1909    }
1910}
1911
1912/// Inline enum for `ClickPipeMySQLPipeSettings.replicationMechanism`.
1913#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1914pub enum ClickPipeMySQLPipeSettingsReplicationmechanism {
1915    #[default]
1916    GTID,
1917    FILE_POS,
1918    /// Catch-all for unknown or newly-added values.
1919    #[serde(untagged)]
1920    Unknown(String),
1921}
1922
1923impl std::fmt::Display for ClickPipeMySQLPipeSettingsReplicationmechanism {
1924    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1925        match self {
1926            Self::GTID => write!(f, "GTID"),
1927            Self::FILE_POS => write!(f, "FILE_POS"),
1928            Self::Unknown(s) => write!(f, "{s}"),
1929        }
1930    }
1931}
1932
1933/// Inline enum for `ClickPipeMySQLPipeSettings.replicationMode`.
1934#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1935pub enum ClickPipeMySQLPipeSettingsReplicationmode {
1936    #[serde(rename = "cdc")]
1937    #[default]
1938    Cdc,
1939    #[serde(rename = "snapshot")]
1940    Snapshot,
1941    #[serde(rename = "cdc_only")]
1942    Cdc_only,
1943    /// Catch-all for unknown or newly-added values.
1944    #[serde(untagged)]
1945    Unknown(String),
1946}
1947
1948impl std::fmt::Display for ClickPipeMySQLPipeSettingsReplicationmode {
1949    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1950        match self {
1951            Self::Cdc => write!(f, "cdc"),
1952            Self::Snapshot => write!(f, "snapshot"),
1953            Self::Cdc_only => write!(f, "cdc_only"),
1954            Self::Unknown(s) => write!(f, "{s}"),
1955        }
1956    }
1957}
1958
1959/// Inline enum for `ClickPipeMySQLPipeTableMapping.tableEngine`.
1960#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1961pub enum ClickPipeMySQLPipeTableMappingTableengine {
1962    #[default]
1963    MergeTree,
1964    ReplacingMergeTree,
1965    Null,
1966    /// Catch-all for unknown or newly-added values.
1967    #[serde(untagged)]
1968    Unknown(String),
1969}
1970
1971impl std::fmt::Display for ClickPipeMySQLPipeTableMappingTableengine {
1972    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1973        match self {
1974            Self::MergeTree => write!(f, "MergeTree"),
1975            Self::ReplacingMergeTree => write!(f, "ReplacingMergeTree"),
1976            Self::Null => write!(f, "Null"),
1977            Self::Unknown(s) => write!(f, "{s}"),
1978        }
1979    }
1980}
1981
1982/// Inline enum for `ClickPipeMySQLSource.authentication`.
1983#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
1984pub enum ClickPipeMySQLSourceAuthentication {
1985    #[serde(rename = "basic")]
1986    #[default]
1987    Basic,
1988    IAM_ROLE,
1989    /// Catch-all for unknown or newly-added values.
1990    #[serde(untagged)]
1991    Unknown(String),
1992}
1993
1994impl std::fmt::Display for ClickPipeMySQLSourceAuthentication {
1995    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
1996        match self {
1997            Self::Basic => write!(f, "basic"),
1998            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
1999            Self::Unknown(s) => write!(f, "{s}"),
2000        }
2001    }
2002}
2003
2004/// Inline enum for `ClickPipeMySQLSource.type`.
2005#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2006pub enum ClickPipeMySQLSourceType {
2007    #[serde(rename = "mysql")]
2008    #[default]
2009    Mysql,
2010    #[serde(rename = "rdsmysql")]
2011    Rdsmysql,
2012    #[serde(rename = "auroramysql")]
2013    Auroramysql,
2014    #[serde(rename = "mariadb")]
2015    Mariadb,
2016    #[serde(rename = "rdsmariadb")]
2017    Rdsmariadb,
2018    /// Catch-all for unknown or newly-added values.
2019    #[serde(untagged)]
2020    Unknown(String),
2021}
2022
2023impl std::fmt::Display for ClickPipeMySQLSourceType {
2024    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2025        match self {
2026            Self::Mysql => write!(f, "mysql"),
2027            Self::Rdsmysql => write!(f, "rdsmysql"),
2028            Self::Auroramysql => write!(f, "auroramysql"),
2029            Self::Mariadb => write!(f, "mariadb"),
2030            Self::Rdsmariadb => write!(f, "rdsmariadb"),
2031            Self::Unknown(s) => write!(f, "{s}"),
2032        }
2033    }
2034}
2035
2036/// Inline enum for `ClickPipeObjectStorageSource.authentication`.
2037#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2038pub enum ClickPipeObjectStorageSourceAuthentication {
2039    #[default]
2040    IAM_ROLE,
2041    IAM_USER,
2042    CONNECTION_STRING,
2043    SERVICE_ACCOUNT,
2044    /// Catch-all for unknown or newly-added values.
2045    #[serde(untagged)]
2046    Unknown(String),
2047}
2048
2049impl std::fmt::Display for ClickPipeObjectStorageSourceAuthentication {
2050    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2051        match self {
2052            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
2053            Self::IAM_USER => write!(f, "IAM_USER"),
2054            Self::CONNECTION_STRING => write!(f, "CONNECTION_STRING"),
2055            Self::SERVICE_ACCOUNT => write!(f, "SERVICE_ACCOUNT"),
2056            Self::Unknown(s) => write!(f, "{s}"),
2057        }
2058    }
2059}
2060
2061/// Inline enum for `ClickPipeObjectStorageSource.compression`.
2062#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2063pub enum ClickPipeObjectStorageSourceCompression {
2064    #[serde(rename = "none")]
2065    #[default]
2066    None,
2067    #[serde(rename = "gzip")]
2068    Gzip,
2069    #[serde(rename = "gz")]
2070    Gz,
2071    #[serde(rename = "brotli")]
2072    Brotli,
2073    #[serde(rename = "br")]
2074    Br,
2075    #[serde(rename = "xz")]
2076    Xz,
2077    LZMA,
2078    #[serde(rename = "zstd")]
2079    Zstd,
2080    #[serde(rename = "auto")]
2081    Auto,
2082    /// Catch-all for unknown or newly-added values.
2083    #[serde(untagged)]
2084    Unknown(String),
2085}
2086
2087impl std::fmt::Display for ClickPipeObjectStorageSourceCompression {
2088    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2089        match self {
2090            Self::None => write!(f, "none"),
2091            Self::Gzip => write!(f, "gzip"),
2092            Self::Gz => write!(f, "gz"),
2093            Self::Brotli => write!(f, "brotli"),
2094            Self::Br => write!(f, "br"),
2095            Self::Xz => write!(f, "xz"),
2096            Self::LZMA => write!(f, "LZMA"),
2097            Self::Zstd => write!(f, "zstd"),
2098            Self::Auto => write!(f, "auto"),
2099            Self::Unknown(s) => write!(f, "{s}"),
2100        }
2101    }
2102}
2103
2104/// Inline enum for `ClickPipeObjectStorageSource.format`.
2105#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2106pub enum ClickPipeObjectStorageSourceFormat {
2107    #[default]
2108    JSONEachRow,
2109    JSONAsObject,
2110    CSV,
2111    CSVWithNames,
2112    TabSeparated,
2113    TabSeparatedWithNames,
2114    Parquet,
2115    Avro,
2116    /// Catch-all for unknown or newly-added values.
2117    #[serde(untagged)]
2118    Unknown(String),
2119}
2120
2121impl std::fmt::Display for ClickPipeObjectStorageSourceFormat {
2122    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2123        match self {
2124            Self::JSONEachRow => write!(f, "JSONEachRow"),
2125            Self::JSONAsObject => write!(f, "JSONAsObject"),
2126            Self::CSV => write!(f, "CSV"),
2127            Self::CSVWithNames => write!(f, "CSVWithNames"),
2128            Self::TabSeparated => write!(f, "TabSeparated"),
2129            Self::TabSeparatedWithNames => write!(f, "TabSeparatedWithNames"),
2130            Self::Parquet => write!(f, "Parquet"),
2131            Self::Avro => write!(f, "Avro"),
2132            Self::Unknown(s) => write!(f, "{s}"),
2133        }
2134    }
2135}
2136
2137/// Inline enum for `ClickPipeObjectStorageSource.type`.
2138#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2139pub enum ClickPipeObjectStorageSourceType {
2140    #[serde(rename = "s3")]
2141    #[default]
2142    S3,
2143    #[serde(rename = "gcs")]
2144    Gcs,
2145    #[serde(rename = "dospaces")]
2146    Dospaces,
2147    #[serde(rename = "azureblobstorage")]
2148    Azureblobstorage,
2149    #[serde(rename = "cloudflarer2")]
2150    Cloudflarer2,
2151    #[serde(rename = "ovhobjectstorage")]
2152    Ovhobjectstorage,
2153    /// Catch-all for unknown or newly-added values.
2154    #[serde(untagged)]
2155    Unknown(String),
2156}
2157
2158impl std::fmt::Display for ClickPipeObjectStorageSourceType {
2159    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2160        match self {
2161            Self::S3 => write!(f, "s3"),
2162            Self::Gcs => write!(f, "gcs"),
2163            Self::Dospaces => write!(f, "dospaces"),
2164            Self::Azureblobstorage => write!(f, "azureblobstorage"),
2165            Self::Cloudflarer2 => write!(f, "cloudflarer2"),
2166            Self::Ovhobjectstorage => write!(f, "ovhobjectstorage"),
2167            Self::Unknown(s) => write!(f, "{s}"),
2168        }
2169    }
2170}
2171
2172/// Inline enum for `ClickPipePatchKafkaSource.authentication`.
2173#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2174pub enum ClickPipePatchKafkaSourceAuthentication {
2175    #[default]
2176    PLAIN,
2177    #[serde(rename = "SCRAM-SHA-256")]
2178    SCRAM_SHA_256,
2179    #[serde(rename = "SCRAM-SHA-512")]
2180    SCRAM_SHA_512,
2181    IAM_ROLE,
2182    IAM_USER,
2183    MUTUAL_TLS,
2184    /// Catch-all for unknown or newly-added values.
2185    #[serde(untagged)]
2186    Unknown(String),
2187}
2188
2189impl std::fmt::Display for ClickPipePatchKafkaSourceAuthentication {
2190    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2191        match self {
2192            Self::PLAIN => write!(f, "PLAIN"),
2193            Self::SCRAM_SHA_256 => write!(f, "SCRAM-SHA-256"),
2194            Self::SCRAM_SHA_512 => write!(f, "SCRAM-SHA-512"),
2195            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
2196            Self::IAM_USER => write!(f, "IAM_USER"),
2197            Self::MUTUAL_TLS => write!(f, "MUTUAL_TLS"),
2198            Self::Unknown(s) => write!(f, "{s}"),
2199        }
2200    }
2201}
2202
2203/// Inline enum for `ClickPipePatchKinesisSource.authentication`.
2204#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2205pub enum ClickPipePatchKinesisSourceAuthentication {
2206    #[default]
2207    IAM_ROLE,
2208    IAM_USER,
2209    /// Catch-all for unknown or newly-added values.
2210    #[serde(untagged)]
2211    Unknown(String),
2212}
2213
2214impl std::fmt::Display for ClickPipePatchKinesisSourceAuthentication {
2215    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2216        match self {
2217            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
2218            Self::IAM_USER => write!(f, "IAM_USER"),
2219            Self::Unknown(s) => write!(f, "{s}"),
2220        }
2221    }
2222}
2223
2224/// Inline enum for `ClickPipePatchMongoDBPipeRemoveTableMapping.tableEngine`.
2225#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2226pub enum ClickPipePatchMongoDBPipeRemoveTableMappingTableengine {
2227    #[default]
2228    MergeTree,
2229    ReplacingMergeTree,
2230    Null,
2231    /// Catch-all for unknown or newly-added values.
2232    #[serde(untagged)]
2233    Unknown(String),
2234}
2235
2236impl std::fmt::Display for ClickPipePatchMongoDBPipeRemoveTableMappingTableengine {
2237    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2238        match self {
2239            Self::MergeTree => write!(f, "MergeTree"),
2240            Self::ReplacingMergeTree => write!(f, "ReplacingMergeTree"),
2241            Self::Null => write!(f, "Null"),
2242            Self::Unknown(s) => write!(f, "{s}"),
2243        }
2244    }
2245}
2246
2247/// Inline enum for `ClickPipePatchMongoDBSource.readPreference`.
2248#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2249pub enum ClickPipePatchMongoDBSourceReadpreference {
2250    #[serde(rename = "primary")]
2251    #[default]
2252    Primary,
2253    #[serde(rename = "primaryPreferred")]
2254    PrimaryPreferred,
2255    #[serde(rename = "secondary")]
2256    Secondary,
2257    #[serde(rename = "secondaryPreferred")]
2258    SecondaryPreferred,
2259    #[serde(rename = "nearest")]
2260    Nearest,
2261    /// Catch-all for unknown or newly-added values.
2262    #[serde(untagged)]
2263    Unknown(String),
2264}
2265
2266impl std::fmt::Display for ClickPipePatchMongoDBSourceReadpreference {
2267    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2268        match self {
2269            Self::Primary => write!(f, "primary"),
2270            Self::PrimaryPreferred => write!(f, "primaryPreferred"),
2271            Self::Secondary => write!(f, "secondary"),
2272            Self::SecondaryPreferred => write!(f, "secondaryPreferred"),
2273            Self::Nearest => write!(f, "nearest"),
2274            Self::Unknown(s) => write!(f, "{s}"),
2275        }
2276    }
2277}
2278
2279/// Inline enum for `ClickPipePatchMySQLPipeRemoveTableMapping.tableEngine`.
2280#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2281pub enum ClickPipePatchMySQLPipeRemoveTableMappingTableengine {
2282    #[default]
2283    MergeTree,
2284    ReplacingMergeTree,
2285    Null,
2286    /// Catch-all for unknown or newly-added values.
2287    #[serde(untagged)]
2288    Unknown(String),
2289}
2290
2291impl std::fmt::Display for ClickPipePatchMySQLPipeRemoveTableMappingTableengine {
2292    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2293        match self {
2294            Self::MergeTree => write!(f, "MergeTree"),
2295            Self::ReplacingMergeTree => write!(f, "ReplacingMergeTree"),
2296            Self::Null => write!(f, "Null"),
2297            Self::Unknown(s) => write!(f, "{s}"),
2298        }
2299    }
2300}
2301
2302/// Inline enum for `ClickPipePatchMySQLSource.authentication`.
2303#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2304pub enum ClickPipePatchMySQLSourceAuthentication {
2305    #[serde(rename = "basic")]
2306    #[default]
2307    Basic,
2308    IAM_ROLE,
2309    /// Catch-all for unknown or newly-added values.
2310    #[serde(untagged)]
2311    Unknown(String),
2312}
2313
2314impl std::fmt::Display for ClickPipePatchMySQLSourceAuthentication {
2315    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2316        match self {
2317            Self::Basic => write!(f, "basic"),
2318            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
2319            Self::Unknown(s) => write!(f, "{s}"),
2320        }
2321    }
2322}
2323
2324/// Inline enum for `ClickPipePatchObjectStorageSource.authentication`.
2325#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2326pub enum ClickPipePatchObjectStorageSourceAuthentication {
2327    #[default]
2328    IAM_ROLE,
2329    IAM_USER,
2330    CONNECTION_STRING,
2331    SERVICE_ACCOUNT,
2332    /// Catch-all for unknown or newly-added values.
2333    #[serde(untagged)]
2334    Unknown(String),
2335}
2336
2337impl std::fmt::Display for ClickPipePatchObjectStorageSourceAuthentication {
2338    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2339        match self {
2340            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
2341            Self::IAM_USER => write!(f, "IAM_USER"),
2342            Self::CONNECTION_STRING => write!(f, "CONNECTION_STRING"),
2343            Self::SERVICE_ACCOUNT => write!(f, "SERVICE_ACCOUNT"),
2344            Self::Unknown(s) => write!(f, "{s}"),
2345        }
2346    }
2347}
2348
2349/// Inline enum for `ClickPipePatchPostgresPipeRemoveTableMapping.tableEngine`.
2350#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2351pub enum ClickPipePatchPostgresPipeRemoveTableMappingTableengine {
2352    #[default]
2353    MergeTree,
2354    ReplacingMergeTree,
2355    Null,
2356    /// Catch-all for unknown or newly-added values.
2357    #[serde(untagged)]
2358    Unknown(String),
2359}
2360
2361impl std::fmt::Display for ClickPipePatchPostgresPipeRemoveTableMappingTableengine {
2362    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2363        match self {
2364            Self::MergeTree => write!(f, "MergeTree"),
2365            Self::ReplacingMergeTree => write!(f, "ReplacingMergeTree"),
2366            Self::Null => write!(f, "Null"),
2367            Self::Unknown(s) => write!(f, "{s}"),
2368        }
2369    }
2370}
2371
2372/// Inline enum for `ClickPipePatchPubSubSource.authentication`.
2373#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2374pub enum ClickPipePatchPubSubSourceAuthentication {
2375    #[serde(rename = "SERVICE_ACCOUNT")]
2376    #[default]
2377    ServiceAccount,
2378    /// Catch-all for unknown or newly-added values.
2379    #[serde(untagged)]
2380    Unknown(String),
2381}
2382
2383impl std::fmt::Display for ClickPipePatchPubSubSourceAuthentication {
2384    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2385        match self {
2386            Self::ServiceAccount => write!(f, "SERVICE_ACCOUNT"),
2387            Self::Unknown(s) => write!(f, "{s}"),
2388        }
2389    }
2390}
2391
2392/// Inline enum for `ClickPipePostKafkaSource.authentication`.
2393#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2394pub enum ClickPipePostKafkaSourceAuthentication {
2395    #[default]
2396    PLAIN,
2397    #[serde(rename = "SCRAM-SHA-256")]
2398    SCRAM_SHA_256,
2399    #[serde(rename = "SCRAM-SHA-512")]
2400    SCRAM_SHA_512,
2401    IAM_ROLE,
2402    IAM_USER,
2403    MUTUAL_TLS,
2404    /// Catch-all for unknown or newly-added values.
2405    #[serde(untagged)]
2406    Unknown(String),
2407}
2408
2409impl std::fmt::Display for ClickPipePostKafkaSourceAuthentication {
2410    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2411        match self {
2412            Self::PLAIN => write!(f, "PLAIN"),
2413            Self::SCRAM_SHA_256 => write!(f, "SCRAM-SHA-256"),
2414            Self::SCRAM_SHA_512 => write!(f, "SCRAM-SHA-512"),
2415            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
2416            Self::IAM_USER => write!(f, "IAM_USER"),
2417            Self::MUTUAL_TLS => write!(f, "MUTUAL_TLS"),
2418            Self::Unknown(s) => write!(f, "{s}"),
2419        }
2420    }
2421}
2422
2423/// Inline enum for `ClickPipePostKafkaSource.format`.
2424#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2425pub enum ClickPipePostKafkaSourceFormat {
2426    #[default]
2427    JSONEachRow,
2428    Avro,
2429    AvroConfluent,
2430    Protobuf,
2431    /// Catch-all for unknown or newly-added values.
2432    #[serde(untagged)]
2433    Unknown(String),
2434}
2435
2436impl std::fmt::Display for ClickPipePostKafkaSourceFormat {
2437    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2438        match self {
2439            Self::JSONEachRow => write!(f, "JSONEachRow"),
2440            Self::Avro => write!(f, "Avro"),
2441            Self::AvroConfluent => write!(f, "AvroConfluent"),
2442            Self::Protobuf => write!(f, "Protobuf"),
2443            Self::Unknown(s) => write!(f, "{s}"),
2444        }
2445    }
2446}
2447
2448/// Inline enum for `ClickPipePostKafkaSource.type`.
2449#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2450pub enum ClickPipePostKafkaSourceType {
2451    #[serde(rename = "kafka")]
2452    #[default]
2453    Kafka,
2454    #[serde(rename = "redpanda")]
2455    Redpanda,
2456    #[serde(rename = "msk")]
2457    Msk,
2458    #[serde(rename = "gcmk")]
2459    Gcmk,
2460    #[serde(rename = "confluent")]
2461    Confluent,
2462    #[serde(rename = "warpstream")]
2463    Warpstream,
2464    #[serde(rename = "azureeventhub")]
2465    Azureeventhub,
2466    #[serde(rename = "dokafka")]
2467    Dokafka,
2468    /// Catch-all for unknown or newly-added values.
2469    #[serde(untagged)]
2470    Unknown(String),
2471}
2472
2473impl std::fmt::Display for ClickPipePostKafkaSourceType {
2474    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2475        match self {
2476            Self::Kafka => write!(f, "kafka"),
2477            Self::Redpanda => write!(f, "redpanda"),
2478            Self::Msk => write!(f, "msk"),
2479            Self::Gcmk => write!(f, "gcmk"),
2480            Self::Confluent => write!(f, "confluent"),
2481            Self::Warpstream => write!(f, "warpstream"),
2482            Self::Azureeventhub => write!(f, "azureeventhub"),
2483            Self::Dokafka => write!(f, "dokafka"),
2484            Self::Unknown(s) => write!(f, "{s}"),
2485        }
2486    }
2487}
2488
2489/// Inline enum for `ClickPipePostKinesisSource.authentication`.
2490#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2491pub enum ClickPipePostKinesisSourceAuthentication {
2492    #[default]
2493    IAM_ROLE,
2494    IAM_USER,
2495    /// Catch-all for unknown or newly-added values.
2496    #[serde(untagged)]
2497    Unknown(String),
2498}
2499
2500impl std::fmt::Display for ClickPipePostKinesisSourceAuthentication {
2501    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2502        match self {
2503            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
2504            Self::IAM_USER => write!(f, "IAM_USER"),
2505            Self::Unknown(s) => write!(f, "{s}"),
2506        }
2507    }
2508}
2509
2510/// Inline enum for `ClickPipePostKinesisSource.format`.
2511#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2512pub enum ClickPipePostKinesisSourceFormat {
2513    #[default]
2514    JSONEachRow,
2515    Avro,
2516    AvroConfluent,
2517    /// Catch-all for unknown or newly-added values.
2518    #[serde(untagged)]
2519    Unknown(String),
2520}
2521
2522impl std::fmt::Display for ClickPipePostKinesisSourceFormat {
2523    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2524        match self {
2525            Self::JSONEachRow => write!(f, "JSONEachRow"),
2526            Self::Avro => write!(f, "Avro"),
2527            Self::AvroConfluent => write!(f, "AvroConfluent"),
2528            Self::Unknown(s) => write!(f, "{s}"),
2529        }
2530    }
2531}
2532
2533/// Inline enum for `ClickPipePostKinesisSource.iteratorType`.
2534#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2535pub enum ClickPipePostKinesisSourceIteratortype {
2536    #[default]
2537    TRIM_HORIZON,
2538    LATEST,
2539    AT_TIMESTAMP,
2540    /// Catch-all for unknown or newly-added values.
2541    #[serde(untagged)]
2542    Unknown(String),
2543}
2544
2545impl std::fmt::Display for ClickPipePostKinesisSourceIteratortype {
2546    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2547        match self {
2548            Self::TRIM_HORIZON => write!(f, "TRIM_HORIZON"),
2549            Self::LATEST => write!(f, "LATEST"),
2550            Self::AT_TIMESTAMP => write!(f, "AT_TIMESTAMP"),
2551            Self::Unknown(s) => write!(f, "{s}"),
2552        }
2553    }
2554}
2555
2556/// Inline enum for `ClickPipePostObjectStorageSource.authentication`.
2557#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2558pub enum ClickPipePostObjectStorageSourceAuthentication {
2559    #[default]
2560    IAM_ROLE,
2561    IAM_USER,
2562    CONNECTION_STRING,
2563    SERVICE_ACCOUNT,
2564    /// Catch-all for unknown or newly-added values.
2565    #[serde(untagged)]
2566    Unknown(String),
2567}
2568
2569impl std::fmt::Display for ClickPipePostObjectStorageSourceAuthentication {
2570    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2571        match self {
2572            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
2573            Self::IAM_USER => write!(f, "IAM_USER"),
2574            Self::CONNECTION_STRING => write!(f, "CONNECTION_STRING"),
2575            Self::SERVICE_ACCOUNT => write!(f, "SERVICE_ACCOUNT"),
2576            Self::Unknown(s) => write!(f, "{s}"),
2577        }
2578    }
2579}
2580
2581/// Inline enum for `ClickPipePostObjectStorageSource.compression`.
2582#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2583pub enum ClickPipePostObjectStorageSourceCompression {
2584    #[serde(rename = "none")]
2585    #[default]
2586    None,
2587    #[serde(rename = "gzip")]
2588    Gzip,
2589    #[serde(rename = "gz")]
2590    Gz,
2591    #[serde(rename = "brotli")]
2592    Brotli,
2593    #[serde(rename = "br")]
2594    Br,
2595    #[serde(rename = "xz")]
2596    Xz,
2597    LZMA,
2598    #[serde(rename = "zstd")]
2599    Zstd,
2600    #[serde(rename = "auto")]
2601    Auto,
2602    /// Catch-all for unknown or newly-added values.
2603    #[serde(untagged)]
2604    Unknown(String),
2605}
2606
2607impl std::fmt::Display for ClickPipePostObjectStorageSourceCompression {
2608    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2609        match self {
2610            Self::None => write!(f, "none"),
2611            Self::Gzip => write!(f, "gzip"),
2612            Self::Gz => write!(f, "gz"),
2613            Self::Brotli => write!(f, "brotli"),
2614            Self::Br => write!(f, "br"),
2615            Self::Xz => write!(f, "xz"),
2616            Self::LZMA => write!(f, "LZMA"),
2617            Self::Zstd => write!(f, "zstd"),
2618            Self::Auto => write!(f, "auto"),
2619            Self::Unknown(s) => write!(f, "{s}"),
2620        }
2621    }
2622}
2623
2624/// Inline enum for `ClickPipePostObjectStorageSource.format`.
2625#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2626pub enum ClickPipePostObjectStorageSourceFormat {
2627    #[default]
2628    JSONEachRow,
2629    JSONAsObject,
2630    CSV,
2631    CSVWithNames,
2632    TabSeparated,
2633    TabSeparatedWithNames,
2634    Parquet,
2635    Avro,
2636    /// Catch-all for unknown or newly-added values.
2637    #[serde(untagged)]
2638    Unknown(String),
2639}
2640
2641impl std::fmt::Display for ClickPipePostObjectStorageSourceFormat {
2642    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2643        match self {
2644            Self::JSONEachRow => write!(f, "JSONEachRow"),
2645            Self::JSONAsObject => write!(f, "JSONAsObject"),
2646            Self::CSV => write!(f, "CSV"),
2647            Self::CSVWithNames => write!(f, "CSVWithNames"),
2648            Self::TabSeparated => write!(f, "TabSeparated"),
2649            Self::TabSeparatedWithNames => write!(f, "TabSeparatedWithNames"),
2650            Self::Parquet => write!(f, "Parquet"),
2651            Self::Avro => write!(f, "Avro"),
2652            Self::Unknown(s) => write!(f, "{s}"),
2653        }
2654    }
2655}
2656
2657/// Inline enum for `ClickPipePostObjectStorageSource.type`.
2658#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2659pub enum ClickPipePostObjectStorageSourceType {
2660    #[serde(rename = "s3")]
2661    #[default]
2662    S3,
2663    #[serde(rename = "gcs")]
2664    Gcs,
2665    #[serde(rename = "dospaces")]
2666    Dospaces,
2667    #[serde(rename = "azureblobstorage")]
2668    Azureblobstorage,
2669    #[serde(rename = "cloudflarer2")]
2670    Cloudflarer2,
2671    #[serde(rename = "ovhobjectstorage")]
2672    Ovhobjectstorage,
2673    /// Catch-all for unknown or newly-added values.
2674    #[serde(untagged)]
2675    Unknown(String),
2676}
2677
2678impl std::fmt::Display for ClickPipePostObjectStorageSourceType {
2679    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2680        match self {
2681            Self::S3 => write!(f, "s3"),
2682            Self::Gcs => write!(f, "gcs"),
2683            Self::Dospaces => write!(f, "dospaces"),
2684            Self::Azureblobstorage => write!(f, "azureblobstorage"),
2685            Self::Cloudflarer2 => write!(f, "cloudflarer2"),
2686            Self::Ovhobjectstorage => write!(f, "ovhobjectstorage"),
2687            Self::Unknown(s) => write!(f, "{s}"),
2688        }
2689    }
2690}
2691
2692/// Inline enum for `ClickPipePostPubSubSource.authentication`.
2693#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2694pub enum ClickPipePostPubSubSourceAuthentication {
2695    #[serde(rename = "SERVICE_ACCOUNT")]
2696    #[default]
2697    ServiceAccount,
2698    /// Catch-all for unknown or newly-added values.
2699    #[serde(untagged)]
2700    Unknown(String),
2701}
2702
2703impl std::fmt::Display for ClickPipePostPubSubSourceAuthentication {
2704    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2705        match self {
2706            Self::ServiceAccount => write!(f, "SERVICE_ACCOUNT"),
2707            Self::Unknown(s) => write!(f, "{s}"),
2708        }
2709    }
2710}
2711
2712/// Inline enum for `ClickPipePostPubSubSource.format`.
2713#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2714pub enum ClickPipePostPubSubSourceFormat {
2715    #[default]
2716    JSONEachRow,
2717    Avro,
2718    Protobuf,
2719    /// Catch-all for unknown or newly-added values.
2720    #[serde(untagged)]
2721    Unknown(String),
2722}
2723
2724impl std::fmt::Display for ClickPipePostPubSubSourceFormat {
2725    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2726        match self {
2727            Self::JSONEachRow => write!(f, "JSONEachRow"),
2728            Self::Avro => write!(f, "Avro"),
2729            Self::Protobuf => write!(f, "Protobuf"),
2730            Self::Unknown(s) => write!(f, "{s}"),
2731        }
2732    }
2733}
2734
2735/// Inline enum for `ClickPipePostPubSubSource.seekType`.
2736#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2737pub enum ClickPipePostPubSubSourceSeektype {
2738    #[serde(rename = "latest")]
2739    #[default]
2740    Latest,
2741    #[serde(rename = "earliest")]
2742    Earliest,
2743    #[serde(rename = "timestamp")]
2744    Timestamp,
2745    #[serde(rename = "snapshot")]
2746    Snapshot,
2747    /// Catch-all for unknown or newly-added values.
2748    #[serde(untagged)]
2749    Unknown(String),
2750}
2751
2752impl std::fmt::Display for ClickPipePostPubSubSourceSeektype {
2753    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2754        match self {
2755            Self::Latest => write!(f, "latest"),
2756            Self::Earliest => write!(f, "earliest"),
2757            Self::Timestamp => write!(f, "timestamp"),
2758            Self::Snapshot => write!(f, "snapshot"),
2759            Self::Unknown(s) => write!(f, "{s}"),
2760        }
2761    }
2762}
2763
2764/// Inline enum for `ClickPipePostgresPipeSettings.replicationMode`.
2765#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2766pub enum ClickPipePostgresPipeSettingsReplicationmode {
2767    #[serde(rename = "cdc")]
2768    #[default]
2769    Cdc,
2770    #[serde(rename = "snapshot")]
2771    Snapshot,
2772    #[serde(rename = "cdc_only")]
2773    Cdc_only,
2774    /// Catch-all for unknown or newly-added values.
2775    #[serde(untagged)]
2776    Unknown(String),
2777}
2778
2779impl std::fmt::Display for ClickPipePostgresPipeSettingsReplicationmode {
2780    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2781        match self {
2782            Self::Cdc => write!(f, "cdc"),
2783            Self::Snapshot => write!(f, "snapshot"),
2784            Self::Cdc_only => write!(f, "cdc_only"),
2785            Self::Unknown(s) => write!(f, "{s}"),
2786        }
2787    }
2788}
2789
2790/// Inline enum for `ClickPipePostgresPipeTableMapping.tableEngine`.
2791#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2792pub enum ClickPipePostgresPipeTableMappingTableengine {
2793    #[default]
2794    MergeTree,
2795    ReplacingMergeTree,
2796    Null,
2797    /// Catch-all for unknown or newly-added values.
2798    #[serde(untagged)]
2799    Unknown(String),
2800}
2801
2802impl std::fmt::Display for ClickPipePostgresPipeTableMappingTableengine {
2803    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2804        match self {
2805            Self::MergeTree => write!(f, "MergeTree"),
2806            Self::ReplacingMergeTree => write!(f, "ReplacingMergeTree"),
2807            Self::Null => write!(f, "Null"),
2808            Self::Unknown(s) => write!(f, "{s}"),
2809        }
2810    }
2811}
2812
2813/// Inline enum for `ClickPipePostgresSource.authentication`.
2814#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2815pub enum ClickPipePostgresSourceAuthentication {
2816    #[serde(rename = "basic")]
2817    #[default]
2818    Basic,
2819    IAM_ROLE,
2820    /// Catch-all for unknown or newly-added values.
2821    #[serde(untagged)]
2822    Unknown(String),
2823}
2824
2825impl std::fmt::Display for ClickPipePostgresSourceAuthentication {
2826    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2827        match self {
2828            Self::Basic => write!(f, "basic"),
2829            Self::IAM_ROLE => write!(f, "IAM_ROLE"),
2830            Self::Unknown(s) => write!(f, "{s}"),
2831        }
2832    }
2833}
2834
2835/// Inline enum for `ClickPipePostgresSource.type`.
2836#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2837pub enum ClickPipePostgresSourceType {
2838    #[serde(rename = "postgres")]
2839    #[default]
2840    Postgres,
2841    #[serde(rename = "supabase")]
2842    Supabase,
2843    #[serde(rename = "neon")]
2844    Neon,
2845    #[serde(rename = "alloydb")]
2846    Alloydb,
2847    #[serde(rename = "planetscale")]
2848    Planetscale,
2849    #[serde(rename = "rdspostgres")]
2850    Rdspostgres,
2851    #[serde(rename = "aurorapostgres")]
2852    Aurorapostgres,
2853    #[serde(rename = "cloudsqlpostgres")]
2854    Cloudsqlpostgres,
2855    #[serde(rename = "azurepostgres")]
2856    Azurepostgres,
2857    #[serde(rename = "crunchybridge")]
2858    Crunchybridge,
2859    #[serde(rename = "tigerdata")]
2860    Tigerdata,
2861    /// Catch-all for unknown or newly-added values.
2862    #[serde(untagged)]
2863    Unknown(String),
2864}
2865
2866impl std::fmt::Display for ClickPipePostgresSourceType {
2867    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2868        match self {
2869            Self::Postgres => write!(f, "postgres"),
2870            Self::Supabase => write!(f, "supabase"),
2871            Self::Neon => write!(f, "neon"),
2872            Self::Alloydb => write!(f, "alloydb"),
2873            Self::Planetscale => write!(f, "planetscale"),
2874            Self::Rdspostgres => write!(f, "rdspostgres"),
2875            Self::Aurorapostgres => write!(f, "aurorapostgres"),
2876            Self::Cloudsqlpostgres => write!(f, "cloudsqlpostgres"),
2877            Self::Azurepostgres => write!(f, "azurepostgres"),
2878            Self::Crunchybridge => write!(f, "crunchybridge"),
2879            Self::Tigerdata => write!(f, "tigerdata"),
2880            Self::Unknown(s) => write!(f, "{s}"),
2881        }
2882    }
2883}
2884
2885/// Inline enum for `ClickPipePubSubSource.authentication`.
2886#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2887pub enum ClickPipePubSubSourceAuthentication {
2888    #[serde(rename = "SERVICE_ACCOUNT")]
2889    #[default]
2890    ServiceAccount,
2891    /// Catch-all for unknown or newly-added values.
2892    #[serde(untagged)]
2893    Unknown(String),
2894}
2895
2896impl std::fmt::Display for ClickPipePubSubSourceAuthentication {
2897    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2898        match self {
2899            Self::ServiceAccount => write!(f, "SERVICE_ACCOUNT"),
2900            Self::Unknown(s) => write!(f, "{s}"),
2901        }
2902    }
2903}
2904
2905/// Inline enum for `ClickPipePubSubSource.format`.
2906#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2907pub enum ClickPipePubSubSourceFormat {
2908    #[default]
2909    JSONEachRow,
2910    Avro,
2911    Protobuf,
2912    /// Catch-all for unknown or newly-added values.
2913    #[serde(untagged)]
2914    Unknown(String),
2915}
2916
2917impl std::fmt::Display for ClickPipePubSubSourceFormat {
2918    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2919        match self {
2920            Self::JSONEachRow => write!(f, "JSONEachRow"),
2921            Self::Avro => write!(f, "Avro"),
2922            Self::Protobuf => write!(f, "Protobuf"),
2923            Self::Unknown(s) => write!(f, "{s}"),
2924        }
2925    }
2926}
2927
2928/// Inline enum for `ClickPipePubSubSource.seekType`.
2929#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2930pub enum ClickPipePubSubSourceSeektype {
2931    #[serde(rename = "latest")]
2932    #[default]
2933    Latest,
2934    #[serde(rename = "earliest")]
2935    Earliest,
2936    #[serde(rename = "timestamp")]
2937    Timestamp,
2938    #[serde(rename = "snapshot")]
2939    Snapshot,
2940    /// Catch-all for unknown or newly-added values.
2941    #[serde(untagged)]
2942    Unknown(String),
2943}
2944
2945impl std::fmt::Display for ClickPipePubSubSourceSeektype {
2946    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2947        match self {
2948            Self::Latest => write!(f, "latest"),
2949            Self::Earliest => write!(f, "earliest"),
2950            Self::Timestamp => write!(f, "timestamp"),
2951            Self::Snapshot => write!(f, "snapshot"),
2952            Self::Unknown(s) => write!(f, "{s}"),
2953        }
2954    }
2955}
2956
2957/// Inline enum for `ClickPipeStatePatchRequest.command`.
2958#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2959pub enum ClickPipeStatePatchRequestCommand {
2960    #[serde(rename = "start")]
2961    #[default]
2962    Start,
2963    #[serde(rename = "stop")]
2964    Stop,
2965    #[serde(rename = "resync")]
2966    Resync,
2967    /// Catch-all for unknown or newly-added values.
2968    #[serde(untagged)]
2969    Unknown(String),
2970}
2971
2972impl std::fmt::Display for ClickPipeStatePatchRequestCommand {
2973    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2974        match self {
2975            Self::Start => write!(f, "start"),
2976            Self::Stop => write!(f, "stop"),
2977            Self::Resync => write!(f, "resync"),
2978            Self::Unknown(s) => write!(f, "{s}"),
2979        }
2980    }
2981}
2982
2983/// Inline enum for `ClickStackAlertChannelEmail.type`.
2984#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
2985pub enum ClickStackAlertChannelEmailType {
2986    #[serde(rename = "webhook")]
2987    #[default]
2988    Webhook,
2989    #[serde(rename = "email")]
2990    Email,
2991    /// Catch-all for unknown or newly-added values.
2992    #[serde(untagged)]
2993    Unknown(String),
2994}
2995
2996impl std::fmt::Display for ClickStackAlertChannelEmailType {
2997    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
2998        match self {
2999            Self::Webhook => write!(f, "webhook"),
3000            Self::Email => write!(f, "email"),
3001            Self::Unknown(s) => write!(f, "{s}"),
3002        }
3003    }
3004}
3005
3006/// Inline enum for `ClickStackAlertChannelWebhook.severity`.
3007#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3008pub enum ClickStackAlertChannelWebhookSeverity {
3009    #[serde(rename = "critical")]
3010    #[default]
3011    Critical,
3012    #[serde(rename = "error")]
3013    Error,
3014    #[serde(rename = "warning")]
3015    Warning,
3016    #[serde(rename = "info")]
3017    Info,
3018    /// Catch-all for unknown or newly-added values.
3019    #[serde(untagged)]
3020    Unknown(String),
3021}
3022
3023impl std::fmt::Display for ClickStackAlertChannelWebhookSeverity {
3024    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3025        match self {
3026            Self::Critical => write!(f, "critical"),
3027            Self::Error => write!(f, "error"),
3028            Self::Warning => write!(f, "warning"),
3029            Self::Info => write!(f, "info"),
3030            Self::Unknown(s) => write!(f, "{s}"),
3031        }
3032    }
3033}
3034
3035/// Inline enum for `ClickStackAlertChannelWebhook.type`.
3036#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3037pub enum ClickStackAlertChannelWebhookType {
3038    #[serde(rename = "webhook")]
3039    #[default]
3040    Webhook,
3041    #[serde(rename = "email")]
3042    Email,
3043    /// Catch-all for unknown or newly-added values.
3044    #[serde(untagged)]
3045    Unknown(String),
3046}
3047
3048impl std::fmt::Display for ClickStackAlertChannelWebhookType {
3049    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3050        match self {
3051            Self::Webhook => write!(f, "webhook"),
3052            Self::Email => write!(f, "email"),
3053            Self::Unknown(s) => write!(f, "{s}"),
3054        }
3055    }
3056}
3057
3058/// Inline enum for `ClickStackAlertExecutionError.type`.
3059#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3060pub enum ClickStackAlertExecutionErrorType {
3061    #[default]
3062    QUERY_ERROR,
3063    WEBHOOK_ERROR,
3064    INVALID_ALERT,
3065    UNKNOWN,
3066    /// Catch-all for unknown or newly-added values.
3067    #[serde(untagged)]
3068    Unknown(String),
3069}
3070
3071impl std::fmt::Display for ClickStackAlertExecutionErrorType {
3072    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3073        match self {
3074            Self::QUERY_ERROR => write!(f, "QUERY_ERROR"),
3075            Self::WEBHOOK_ERROR => write!(f, "WEBHOOK_ERROR"),
3076            Self::INVALID_ALERT => write!(f, "INVALID_ALERT"),
3077            Self::UNKNOWN => write!(f, "UNKNOWN"),
3078            Self::Unknown(s) => write!(f, "{s}"),
3079        }
3080    }
3081}
3082
3083/// Inline enum for `ClickStackAlertResponse.interval`.
3084#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3085pub enum ClickStackAlertResponseInterval {
3086    #[serde(rename = "1m")]
3087    #[default]
3088    _1m,
3089    #[serde(rename = "5m")]
3090    _5m,
3091    #[serde(rename = "15m")]
3092    _15m,
3093    #[serde(rename = "30m")]
3094    _30m,
3095    #[serde(rename = "1h")]
3096    _1h,
3097    #[serde(rename = "6h")]
3098    _6h,
3099    #[serde(rename = "12h")]
3100    _12h,
3101    #[serde(rename = "1d")]
3102    _1d,
3103    /// Catch-all for unknown or newly-added values.
3104    #[serde(untagged)]
3105    Unknown(String),
3106}
3107
3108impl std::fmt::Display for ClickStackAlertResponseInterval {
3109    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3110        match self {
3111            Self::_1m => write!(f, "1m"),
3112            Self::_5m => write!(f, "5m"),
3113            Self::_15m => write!(f, "15m"),
3114            Self::_30m => write!(f, "30m"),
3115            Self::_1h => write!(f, "1h"),
3116            Self::_6h => write!(f, "6h"),
3117            Self::_12h => write!(f, "12h"),
3118            Self::_1d => write!(f, "1d"),
3119            Self::Unknown(s) => write!(f, "{s}"),
3120        }
3121    }
3122}
3123
3124/// Inline enum for `ClickStackAlertResponse.source`.
3125#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3126pub enum ClickStackAlertResponseSource {
3127    #[serde(rename = "saved_search")]
3128    #[default]
3129    Saved_search,
3130    #[serde(rename = "tile")]
3131    Tile,
3132    /// Catch-all for unknown or newly-added values.
3133    #[serde(untagged)]
3134    Unknown(String),
3135}
3136
3137impl std::fmt::Display for ClickStackAlertResponseSource {
3138    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3139        match self {
3140            Self::Saved_search => write!(f, "saved_search"),
3141            Self::Tile => write!(f, "tile"),
3142            Self::Unknown(s) => write!(f, "{s}"),
3143        }
3144    }
3145}
3146
3147/// Inline enum for `ClickStackAlertResponse.state`.
3148#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3149pub enum ClickStackAlertResponseState {
3150    #[default]
3151    ALERT,
3152    OK,
3153    INSUFFICIENT_DATA,
3154    DISABLED,
3155    /// Catch-all for unknown or newly-added values.
3156    #[serde(untagged)]
3157    Unknown(String),
3158}
3159
3160impl std::fmt::Display for ClickStackAlertResponseState {
3161    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3162        match self {
3163            Self::ALERT => write!(f, "ALERT"),
3164            Self::OK => write!(f, "OK"),
3165            Self::INSUFFICIENT_DATA => write!(f, "INSUFFICIENT_DATA"),
3166            Self::DISABLED => write!(f, "DISABLED"),
3167            Self::Unknown(s) => write!(f, "{s}"),
3168        }
3169    }
3170}
3171
3172/// Inline enum for `ClickStackAlertResponse.thresholdType`.
3173#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3174pub enum ClickStackAlertResponseThresholdtype {
3175    #[serde(rename = "above")]
3176    #[default]
3177    Above,
3178    #[serde(rename = "below")]
3179    Below,
3180    /// Catch-all for unknown or newly-added values.
3181    #[serde(untagged)]
3182    Unknown(String),
3183}
3184
3185impl std::fmt::Display for ClickStackAlertResponseThresholdtype {
3186    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3187        match self {
3188            Self::Above => write!(f, "above"),
3189            Self::Below => write!(f, "below"),
3190            Self::Unknown(s) => write!(f, "{s}"),
3191        }
3192    }
3193}
3194
3195/// Inline enum for `ClickStackBarBuilderChartConfig.displayType`.
3196#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3197pub enum ClickStackBarBuilderChartConfigDisplaytype {
3198    #[serde(rename = "stacked_bar")]
3199    #[default]
3200    Stacked_bar,
3201    /// Catch-all for unknown or newly-added values.
3202    #[serde(untagged)]
3203    Unknown(String),
3204}
3205
3206impl std::fmt::Display for ClickStackBarBuilderChartConfigDisplaytype {
3207    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3208        match self {
3209            Self::Stacked_bar => write!(f, "stacked_bar"),
3210            Self::Unknown(s) => write!(f, "{s}"),
3211        }
3212    }
3213}
3214
3215/// Inline enum for `ClickStackBarRawSqlChartConfig.configType`.
3216#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3217pub enum ClickStackBarRawSqlChartConfigConfigtype {
3218    #[serde(rename = "sql")]
3219    #[default]
3220    Sql,
3221    /// Catch-all for unknown or newly-added values.
3222    #[serde(untagged)]
3223    Unknown(String),
3224}
3225
3226impl std::fmt::Display for ClickStackBarRawSqlChartConfigConfigtype {
3227    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3228        match self {
3229            Self::Sql => write!(f, "sql"),
3230            Self::Unknown(s) => write!(f, "{s}"),
3231        }
3232    }
3233}
3234
3235/// Inline enum for `ClickStackBarRawSqlChartConfig.displayType`.
3236#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3237pub enum ClickStackBarRawSqlChartConfigDisplaytype {
3238    #[serde(rename = "stacked_bar")]
3239    #[default]
3240    Stacked_bar,
3241    /// Catch-all for unknown or newly-added values.
3242    #[serde(untagged)]
3243    Unknown(String),
3244}
3245
3246impl std::fmt::Display for ClickStackBarRawSqlChartConfigDisplaytype {
3247    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3248        match self {
3249            Self::Stacked_bar => write!(f, "stacked_bar"),
3250            Self::Unknown(s) => write!(f, "{s}"),
3251        }
3252    }
3253}
3254
3255/// Inline enum for `ClickStackCreateAlertRequest.interval`.
3256#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3257pub enum ClickStackCreateAlertRequestInterval {
3258    #[serde(rename = "1m")]
3259    #[default]
3260    _1m,
3261    #[serde(rename = "5m")]
3262    _5m,
3263    #[serde(rename = "15m")]
3264    _15m,
3265    #[serde(rename = "30m")]
3266    _30m,
3267    #[serde(rename = "1h")]
3268    _1h,
3269    #[serde(rename = "6h")]
3270    _6h,
3271    #[serde(rename = "12h")]
3272    _12h,
3273    #[serde(rename = "1d")]
3274    _1d,
3275    /// Catch-all for unknown or newly-added values.
3276    #[serde(untagged)]
3277    Unknown(String),
3278}
3279
3280impl std::fmt::Display for ClickStackCreateAlertRequestInterval {
3281    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3282        match self {
3283            Self::_1m => write!(f, "1m"),
3284            Self::_5m => write!(f, "5m"),
3285            Self::_15m => write!(f, "15m"),
3286            Self::_30m => write!(f, "30m"),
3287            Self::_1h => write!(f, "1h"),
3288            Self::_6h => write!(f, "6h"),
3289            Self::_12h => write!(f, "12h"),
3290            Self::_1d => write!(f, "1d"),
3291            Self::Unknown(s) => write!(f, "{s}"),
3292        }
3293    }
3294}
3295
3296/// Inline enum for `ClickStackCreateAlertRequest.source`.
3297#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3298pub enum ClickStackCreateAlertRequestSource {
3299    #[serde(rename = "saved_search")]
3300    #[default]
3301    Saved_search,
3302    #[serde(rename = "tile")]
3303    Tile,
3304    /// Catch-all for unknown or newly-added values.
3305    #[serde(untagged)]
3306    Unknown(String),
3307}
3308
3309impl std::fmt::Display for ClickStackCreateAlertRequestSource {
3310    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3311        match self {
3312            Self::Saved_search => write!(f, "saved_search"),
3313            Self::Tile => write!(f, "tile"),
3314            Self::Unknown(s) => write!(f, "{s}"),
3315        }
3316    }
3317}
3318
3319/// Inline enum for `ClickStackCreateAlertRequest.thresholdType`.
3320#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3321pub enum ClickStackCreateAlertRequestThresholdtype {
3322    #[serde(rename = "above")]
3323    #[default]
3324    Above,
3325    #[serde(rename = "below")]
3326    Below,
3327    /// Catch-all for unknown or newly-added values.
3328    #[serde(untagged)]
3329    Unknown(String),
3330}
3331
3332impl std::fmt::Display for ClickStackCreateAlertRequestThresholdtype {
3333    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3334        match self {
3335            Self::Above => write!(f, "above"),
3336            Self::Below => write!(f, "below"),
3337            Self::Unknown(s) => write!(f, "{s}"),
3338        }
3339    }
3340}
3341
3342/// Inline enum for `ClickStackCreateDashboardRequest.savedQueryLanguage`.
3343#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3344pub enum ClickStackCreateDashboardRequestSavedquerylanguage {
3345    #[serde(rename = "sql")]
3346    #[default]
3347    Sql,
3348    #[serde(rename = "lucene")]
3349    Lucene,
3350    /// Catch-all for unknown or newly-added values.
3351    #[serde(untagged)]
3352    Unknown(String),
3353}
3354
3355impl std::fmt::Display for ClickStackCreateDashboardRequestSavedquerylanguage {
3356    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3357        match self {
3358            Self::Sql => write!(f, "sql"),
3359            Self::Lucene => write!(f, "lucene"),
3360            Self::Unknown(s) => write!(f, "{s}"),
3361        }
3362    }
3363}
3364
3365/// Inline enum for `ClickStackDashboardResponse.savedQueryLanguage`.
3366#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3367pub enum ClickStackDashboardResponseSavedquerylanguage {
3368    #[serde(rename = "sql")]
3369    #[default]
3370    Sql,
3371    #[serde(rename = "lucene")]
3372    Lucene,
3373    /// Catch-all for unknown or newly-added values.
3374    #[serde(untagged)]
3375    Unknown(String),
3376}
3377
3378impl std::fmt::Display for ClickStackDashboardResponseSavedquerylanguage {
3379    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3380        match self {
3381            Self::Sql => write!(f, "sql"),
3382            Self::Lucene => write!(f, "lucene"),
3383            Self::Unknown(s) => write!(f, "{s}"),
3384        }
3385    }
3386}
3387
3388/// Inline enum for `ClickStackFilter.sourceMetricType`.
3389#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3390pub enum ClickStackFilterSourcemetrictype {
3391    #[serde(rename = "sum")]
3392    #[default]
3393    Sum,
3394    #[serde(rename = "gauge")]
3395    Gauge,
3396    #[serde(rename = "histogram")]
3397    Histogram,
3398    #[serde(rename = "summary")]
3399    Summary,
3400    #[serde(rename = "exponential histogram")]
3401    Exponential_histogram,
3402    /// Catch-all for unknown or newly-added values.
3403    #[serde(untagged)]
3404    Unknown(String),
3405}
3406
3407impl std::fmt::Display for ClickStackFilterSourcemetrictype {
3408    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3409        match self {
3410            Self::Sum => write!(f, "sum"),
3411            Self::Gauge => write!(f, "gauge"),
3412            Self::Histogram => write!(f, "histogram"),
3413            Self::Summary => write!(f, "summary"),
3414            Self::Exponential_histogram => write!(f, "exponential histogram"),
3415            Self::Unknown(s) => write!(f, "{s}"),
3416        }
3417    }
3418}
3419
3420/// Inline enum for `ClickStackFilter.type`.
3421#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3422pub enum ClickStackFilterType {
3423    #[default]
3424    QUERY_EXPRESSION,
3425    /// Catch-all for unknown or newly-added values.
3426    #[serde(untagged)]
3427    Unknown(String),
3428}
3429
3430impl std::fmt::Display for ClickStackFilterType {
3431    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3432        match self {
3433            Self::QUERY_EXPRESSION => write!(f, "QUERY_EXPRESSION"),
3434            Self::Unknown(s) => write!(f, "{s}"),
3435        }
3436    }
3437}
3438
3439/// Inline enum for `ClickStackFilter.whereLanguage`.
3440#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3441pub enum ClickStackFilterWherelanguage {
3442    #[serde(rename = "sql")]
3443    #[default]
3444    Sql,
3445    #[serde(rename = "lucene")]
3446    Lucene,
3447    /// Catch-all for unknown or newly-added values.
3448    #[serde(untagged)]
3449    Unknown(String),
3450}
3451
3452impl std::fmt::Display for ClickStackFilterWherelanguage {
3453    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3454        match self {
3455            Self::Sql => write!(f, "sql"),
3456            Self::Lucene => write!(f, "lucene"),
3457            Self::Unknown(s) => write!(f, "{s}"),
3458        }
3459    }
3460}
3461
3462/// Inline enum for `ClickStackFilterInput.sourceMetricType`.
3463#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3464pub enum ClickStackFilterInputSourcemetrictype {
3465    #[serde(rename = "sum")]
3466    #[default]
3467    Sum,
3468    #[serde(rename = "gauge")]
3469    Gauge,
3470    #[serde(rename = "histogram")]
3471    Histogram,
3472    #[serde(rename = "summary")]
3473    Summary,
3474    #[serde(rename = "exponential histogram")]
3475    Exponential_histogram,
3476    /// Catch-all for unknown or newly-added values.
3477    #[serde(untagged)]
3478    Unknown(String),
3479}
3480
3481impl std::fmt::Display for ClickStackFilterInputSourcemetrictype {
3482    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3483        match self {
3484            Self::Sum => write!(f, "sum"),
3485            Self::Gauge => write!(f, "gauge"),
3486            Self::Histogram => write!(f, "histogram"),
3487            Self::Summary => write!(f, "summary"),
3488            Self::Exponential_histogram => write!(f, "exponential histogram"),
3489            Self::Unknown(s) => write!(f, "{s}"),
3490        }
3491    }
3492}
3493
3494/// Inline enum for `ClickStackFilterInput.type`.
3495#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3496pub enum ClickStackFilterInputType {
3497    #[default]
3498    QUERY_EXPRESSION,
3499    /// Catch-all for unknown or newly-added values.
3500    #[serde(untagged)]
3501    Unknown(String),
3502}
3503
3504impl std::fmt::Display for ClickStackFilterInputType {
3505    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3506        match self {
3507            Self::QUERY_EXPRESSION => write!(f, "QUERY_EXPRESSION"),
3508            Self::Unknown(s) => write!(f, "{s}"),
3509        }
3510    }
3511}
3512
3513/// Inline enum for `ClickStackFilterInput.whereLanguage`.
3514#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3515pub enum ClickStackFilterInputWherelanguage {
3516    #[serde(rename = "sql")]
3517    #[default]
3518    Sql,
3519    #[serde(rename = "lucene")]
3520    Lucene,
3521    /// Catch-all for unknown or newly-added values.
3522    #[serde(untagged)]
3523    Unknown(String),
3524}
3525
3526impl std::fmt::Display for ClickStackFilterInputWherelanguage {
3527    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3528        match self {
3529            Self::Sql => write!(f, "sql"),
3530            Self::Lucene => write!(f, "lucene"),
3531            Self::Unknown(s) => write!(f, "{s}"),
3532        }
3533    }
3534}
3535
3536/// Inline enum for `ClickStackGenericWebhook.service`.
3537#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3538pub enum ClickStackGenericWebhookService {
3539    #[serde(rename = "generic")]
3540    #[default]
3541    Generic,
3542    /// Catch-all for unknown or newly-added values.
3543    #[serde(untagged)]
3544    Unknown(String),
3545}
3546
3547impl std::fmt::Display for ClickStackGenericWebhookService {
3548    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3549        match self {
3550            Self::Generic => write!(f, "generic"),
3551            Self::Unknown(s) => write!(f, "{s}"),
3552        }
3553    }
3554}
3555
3556/// Inline enum for `ClickStackHeatmapChartConfig.displayType`.
3557#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3558pub enum ClickStackHeatmapChartConfigDisplaytype {
3559    #[serde(rename = "heatmap")]
3560    #[default]
3561    Heatmap,
3562    /// Catch-all for unknown or newly-added values.
3563    #[serde(untagged)]
3564    Unknown(String),
3565}
3566
3567impl std::fmt::Display for ClickStackHeatmapChartConfigDisplaytype {
3568    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3569        match self {
3570            Self::Heatmap => write!(f, "heatmap"),
3571            Self::Unknown(s) => write!(f, "{s}"),
3572        }
3573    }
3574}
3575
3576/// Inline enum for `ClickStackHeatmapChartConfig.whereLanguage`.
3577#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3578pub enum ClickStackHeatmapChartConfigWherelanguage {
3579    #[serde(rename = "sql")]
3580    #[default]
3581    Sql,
3582    #[serde(rename = "lucene")]
3583    Lucene,
3584    /// Catch-all for unknown or newly-added values.
3585    #[serde(untagged)]
3586    Unknown(String),
3587}
3588
3589impl std::fmt::Display for ClickStackHeatmapChartConfigWherelanguage {
3590    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3591        match self {
3592            Self::Sql => write!(f, "sql"),
3593            Self::Lucene => write!(f, "lucene"),
3594            Self::Unknown(s) => write!(f, "{s}"),
3595        }
3596    }
3597}
3598
3599/// Inline enum for `ClickStackHeatmapSelectItem.heatmapScaleType`.
3600#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3601pub enum ClickStackHeatmapSelectItemHeatmapscaletype {
3602    #[serde(rename = "log")]
3603    #[default]
3604    Log,
3605    #[serde(rename = "linear")]
3606    Linear,
3607    /// Catch-all for unknown or newly-added values.
3608    #[serde(untagged)]
3609    Unknown(String),
3610}
3611
3612impl std::fmt::Display for ClickStackHeatmapSelectItemHeatmapscaletype {
3613    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3614        match self {
3615            Self::Log => write!(f, "log"),
3616            Self::Linear => write!(f, "linear"),
3617            Self::Unknown(s) => write!(f, "{s}"),
3618        }
3619    }
3620}
3621
3622/// Inline enum for `ClickStackIncidentIOWebhook.service`.
3623#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3624pub enum ClickStackIncidentIOWebhookService {
3625    #[serde(rename = "incidentio")]
3626    #[default]
3627    Incidentio,
3628    /// Catch-all for unknown or newly-added values.
3629    #[serde(untagged)]
3630    Unknown(String),
3631}
3632
3633impl std::fmt::Display for ClickStackIncidentIOWebhookService {
3634    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3635        match self {
3636            Self::Incidentio => write!(f, "incidentio"),
3637            Self::Unknown(s) => write!(f, "{s}"),
3638        }
3639    }
3640}
3641
3642/// Inline enum for `ClickStackLineBuilderChartConfig.displayType`.
3643#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3644pub enum ClickStackLineBuilderChartConfigDisplaytype {
3645    #[serde(rename = "line")]
3646    #[default]
3647    Line,
3648    /// Catch-all for unknown or newly-added values.
3649    #[serde(untagged)]
3650    Unknown(String),
3651}
3652
3653impl std::fmt::Display for ClickStackLineBuilderChartConfigDisplaytype {
3654    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3655        match self {
3656            Self::Line => write!(f, "line"),
3657            Self::Unknown(s) => write!(f, "{s}"),
3658        }
3659    }
3660}
3661
3662/// Inline enum for `ClickStackLineRawSqlChartConfig.configType`.
3663#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3664pub enum ClickStackLineRawSqlChartConfigConfigtype {
3665    #[serde(rename = "sql")]
3666    #[default]
3667    Sql,
3668    /// Catch-all for unknown or newly-added values.
3669    #[serde(untagged)]
3670    Unknown(String),
3671}
3672
3673impl std::fmt::Display for ClickStackLineRawSqlChartConfigConfigtype {
3674    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3675        match self {
3676            Self::Sql => write!(f, "sql"),
3677            Self::Unknown(s) => write!(f, "{s}"),
3678        }
3679    }
3680}
3681
3682/// Inline enum for `ClickStackLineRawSqlChartConfig.displayType`.
3683#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3684pub enum ClickStackLineRawSqlChartConfigDisplaytype {
3685    #[serde(rename = "line")]
3686    #[default]
3687    Line,
3688    /// Catch-all for unknown or newly-added values.
3689    #[serde(untagged)]
3690    Unknown(String),
3691}
3692
3693impl std::fmt::Display for ClickStackLineRawSqlChartConfigDisplaytype {
3694    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3695        match self {
3696            Self::Line => write!(f, "line"),
3697            Self::Unknown(s) => write!(f, "{s}"),
3698        }
3699    }
3700}
3701
3702/// Inline enum for `ClickStackLogSource.kind`.
3703#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3704pub enum ClickStackLogSourceKind {
3705    #[serde(rename = "log")]
3706    #[default]
3707    Log,
3708    /// Catch-all for unknown or newly-added values.
3709    #[serde(untagged)]
3710    Unknown(String),
3711}
3712
3713impl std::fmt::Display for ClickStackLogSourceKind {
3714    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3715        match self {
3716            Self::Log => write!(f, "log"),
3717            Self::Unknown(s) => write!(f, "{s}"),
3718        }
3719    }
3720}
3721
3722/// Inline enum for `ClickStackMarkdownChartConfig.displayType`.
3723#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3724pub enum ClickStackMarkdownChartConfigDisplaytype {
3725    #[serde(rename = "markdown")]
3726    #[default]
3727    Markdown,
3728    /// Catch-all for unknown or newly-added values.
3729    #[serde(untagged)]
3730    Unknown(String),
3731}
3732
3733impl std::fmt::Display for ClickStackMarkdownChartConfigDisplaytype {
3734    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3735        match self {
3736            Self::Markdown => write!(f, "markdown"),
3737            Self::Unknown(s) => write!(f, "{s}"),
3738        }
3739    }
3740}
3741
3742/// Inline enum for `ClickStackMarkdownChartSeries.type`.
3743#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3744pub enum ClickStackMarkdownChartSeriesType {
3745    #[serde(rename = "markdown")]
3746    #[default]
3747    Markdown,
3748    /// Catch-all for unknown or newly-added values.
3749    #[serde(untagged)]
3750    Unknown(String),
3751}
3752
3753impl std::fmt::Display for ClickStackMarkdownChartSeriesType {
3754    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3755        match self {
3756            Self::Markdown => write!(f, "markdown"),
3757            Self::Unknown(s) => write!(f, "{s}"),
3758        }
3759    }
3760}
3761
3762/// Inline enum for `ClickStackMaterializedView.minGranularity`.
3763#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3764pub enum ClickStackMaterializedViewMingranularity {
3765    #[serde(rename = "1s")]
3766    #[default]
3767    _1s,
3768    #[serde(rename = "15s")]
3769    _15s,
3770    #[serde(rename = "30s")]
3771    _30s,
3772    #[serde(rename = "1m")]
3773    _1m,
3774    #[serde(rename = "5m")]
3775    _5m,
3776    #[serde(rename = "15m")]
3777    _15m,
3778    #[serde(rename = "30m")]
3779    _30m,
3780    #[serde(rename = "1h")]
3781    _1h,
3782    #[serde(rename = "2h")]
3783    _2h,
3784    #[serde(rename = "6h")]
3785    _6h,
3786    #[serde(rename = "12h")]
3787    _12h,
3788    #[serde(rename = "1d")]
3789    _1d,
3790    #[serde(rename = "2d")]
3791    _2d,
3792    #[serde(rename = "7d")]
3793    _7d,
3794    #[serde(rename = "30d")]
3795    _30d,
3796    /// Catch-all for unknown or newly-added values.
3797    #[serde(untagged)]
3798    Unknown(String),
3799}
3800
3801impl std::fmt::Display for ClickStackMaterializedViewMingranularity {
3802    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3803        match self {
3804            Self::_1s => write!(f, "1s"),
3805            Self::_15s => write!(f, "15s"),
3806            Self::_30s => write!(f, "30s"),
3807            Self::_1m => write!(f, "1m"),
3808            Self::_5m => write!(f, "5m"),
3809            Self::_15m => write!(f, "15m"),
3810            Self::_30m => write!(f, "30m"),
3811            Self::_1h => write!(f, "1h"),
3812            Self::_2h => write!(f, "2h"),
3813            Self::_6h => write!(f, "6h"),
3814            Self::_12h => write!(f, "12h"),
3815            Self::_1d => write!(f, "1d"),
3816            Self::_2d => write!(f, "2d"),
3817            Self::_7d => write!(f, "7d"),
3818            Self::_30d => write!(f, "30d"),
3819            Self::Unknown(s) => write!(f, "{s}"),
3820        }
3821    }
3822}
3823
3824/// Inline enum for `ClickStackMetricSource.kind`.
3825#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3826pub enum ClickStackMetricSourceKind {
3827    #[serde(rename = "metric")]
3828    #[default]
3829    Metric,
3830    /// Catch-all for unknown or newly-added values.
3831    #[serde(untagged)]
3832    Unknown(String),
3833}
3834
3835impl std::fmt::Display for ClickStackMetricSourceKind {
3836    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3837        match self {
3838            Self::Metric => write!(f, "metric"),
3839            Self::Unknown(s) => write!(f, "{s}"),
3840        }
3841    }
3842}
3843
3844/// Inline enum for `ClickStackNumberBuilderChartConfig.displayType`.
3845#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3846pub enum ClickStackNumberBuilderChartConfigDisplaytype {
3847    #[serde(rename = "number")]
3848    #[default]
3849    Number,
3850    /// Catch-all for unknown or newly-added values.
3851    #[serde(untagged)]
3852    Unknown(String),
3853}
3854
3855impl std::fmt::Display for ClickStackNumberBuilderChartConfigDisplaytype {
3856    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3857        match self {
3858            Self::Number => write!(f, "number"),
3859            Self::Unknown(s) => write!(f, "{s}"),
3860        }
3861    }
3862}
3863
3864/// Inline enum for `ClickStackNumberChartSeries.aggFn`.
3865#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3866pub enum ClickStackNumberChartSeriesAggfn {
3867    #[serde(rename = "avg")]
3868    #[default]
3869    Avg,
3870    #[serde(rename = "count")]
3871    Count,
3872    #[serde(rename = "count_distinct")]
3873    Count_distinct,
3874    #[serde(rename = "last_value")]
3875    Last_value,
3876    #[serde(rename = "max")]
3877    Max,
3878    #[serde(rename = "min")]
3879    Min,
3880    #[serde(rename = "quantile")]
3881    Quantile,
3882    #[serde(rename = "sum")]
3883    Sum,
3884    #[serde(rename = "any")]
3885    Any,
3886    #[serde(rename = "none")]
3887    None,
3888    /// Catch-all for unknown or newly-added values.
3889    #[serde(untagged)]
3890    Unknown(String),
3891}
3892
3893impl std::fmt::Display for ClickStackNumberChartSeriesAggfn {
3894    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3895        match self {
3896            Self::Avg => write!(f, "avg"),
3897            Self::Count => write!(f, "count"),
3898            Self::Count_distinct => write!(f, "count_distinct"),
3899            Self::Last_value => write!(f, "last_value"),
3900            Self::Max => write!(f, "max"),
3901            Self::Min => write!(f, "min"),
3902            Self::Quantile => write!(f, "quantile"),
3903            Self::Sum => write!(f, "sum"),
3904            Self::Any => write!(f, "any"),
3905            Self::None => write!(f, "none"),
3906            Self::Unknown(s) => write!(f, "{s}"),
3907        }
3908    }
3909}
3910
3911/// Inline enum for `ClickStackNumberChartSeries.metricDataType`.
3912#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3913pub enum ClickStackNumberChartSeriesMetricdatatype {
3914    #[serde(rename = "sum")]
3915    #[default]
3916    Sum,
3917    #[serde(rename = "gauge")]
3918    Gauge,
3919    #[serde(rename = "histogram")]
3920    Histogram,
3921    #[serde(rename = "summary")]
3922    Summary,
3923    #[serde(rename = "exponential histogram")]
3924    Exponential_histogram,
3925    /// Catch-all for unknown or newly-added values.
3926    #[serde(untagged)]
3927    Unknown(String),
3928}
3929
3930impl std::fmt::Display for ClickStackNumberChartSeriesMetricdatatype {
3931    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3932        match self {
3933            Self::Sum => write!(f, "sum"),
3934            Self::Gauge => write!(f, "gauge"),
3935            Self::Histogram => write!(f, "histogram"),
3936            Self::Summary => write!(f, "summary"),
3937            Self::Exponential_histogram => write!(f, "exponential histogram"),
3938            Self::Unknown(s) => write!(f, "{s}"),
3939        }
3940    }
3941}
3942
3943/// Inline enum for `ClickStackNumberChartSeries.type`.
3944#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3945pub enum ClickStackNumberChartSeriesType {
3946    #[serde(rename = "number")]
3947    #[default]
3948    Number,
3949    /// Catch-all for unknown or newly-added values.
3950    #[serde(untagged)]
3951    Unknown(String),
3952}
3953
3954impl std::fmt::Display for ClickStackNumberChartSeriesType {
3955    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3956        match self {
3957            Self::Number => write!(f, "number"),
3958            Self::Unknown(s) => write!(f, "{s}"),
3959        }
3960    }
3961}
3962
3963/// Inline enum for `ClickStackNumberChartSeries.whereLanguage`.
3964#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3965pub enum ClickStackNumberChartSeriesWherelanguage {
3966    #[serde(rename = "sql")]
3967    #[default]
3968    Sql,
3969    #[serde(rename = "lucene")]
3970    Lucene,
3971    /// Catch-all for unknown or newly-added values.
3972    #[serde(untagged)]
3973    Unknown(String),
3974}
3975
3976impl std::fmt::Display for ClickStackNumberChartSeriesWherelanguage {
3977    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
3978        match self {
3979            Self::Sql => write!(f, "sql"),
3980            Self::Lucene => write!(f, "lucene"),
3981            Self::Unknown(s) => write!(f, "{s}"),
3982        }
3983    }
3984}
3985
3986/// Inline enum for `ClickStackNumberFormat.numericUnit`.
3987#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
3988pub enum ClickStackNumberFormatNumericunit {
3989    #[serde(rename = "bytes_iec")]
3990    #[default]
3991    Bytes_iec,
3992    #[serde(rename = "bytes_si")]
3993    Bytes_si,
3994    #[serde(rename = "bits_iec")]
3995    Bits_iec,
3996    #[serde(rename = "bits_si")]
3997    Bits_si,
3998    #[serde(rename = "kibibytes")]
3999    Kibibytes,
4000    #[serde(rename = "kilobytes")]
4001    Kilobytes,
4002    #[serde(rename = "mebibytes")]
4003    Mebibytes,
4004    #[serde(rename = "megabytes")]
4005    Megabytes,
4006    #[serde(rename = "gibibytes")]
4007    Gibibytes,
4008    #[serde(rename = "gigabytes")]
4009    Gigabytes,
4010    #[serde(rename = "tebibytes")]
4011    Tebibytes,
4012    #[serde(rename = "terabytes")]
4013    Terabytes,
4014    #[serde(rename = "pebibytes")]
4015    Pebibytes,
4016    #[serde(rename = "petabytes")]
4017    Petabytes,
4018    #[serde(rename = "packets_sec")]
4019    Packets_sec,
4020    #[serde(rename = "bytes_sec_iec")]
4021    Bytes_sec_iec,
4022    #[serde(rename = "bytes_sec_si")]
4023    Bytes_sec_si,
4024    #[serde(rename = "bits_sec_iec")]
4025    Bits_sec_iec,
4026    #[serde(rename = "bits_sec_si")]
4027    Bits_sec_si,
4028    #[serde(rename = "kibibytes_sec")]
4029    Kibibytes_sec,
4030    #[serde(rename = "kibibits_sec")]
4031    Kibibits_sec,
4032    #[serde(rename = "kilobytes_sec")]
4033    Kilobytes_sec,
4034    #[serde(rename = "kilobits_sec")]
4035    Kilobits_sec,
4036    #[serde(rename = "mebibytes_sec")]
4037    Mebibytes_sec,
4038    #[serde(rename = "mebibits_sec")]
4039    Mebibits_sec,
4040    #[serde(rename = "megabytes_sec")]
4041    Megabytes_sec,
4042    #[serde(rename = "megabits_sec")]
4043    Megabits_sec,
4044    #[serde(rename = "gibibytes_sec")]
4045    Gibibytes_sec,
4046    #[serde(rename = "gibibits_sec")]
4047    Gibibits_sec,
4048    #[serde(rename = "gigabytes_sec")]
4049    Gigabytes_sec,
4050    #[serde(rename = "gigabits_sec")]
4051    Gigabits_sec,
4052    #[serde(rename = "tebibytes_sec")]
4053    Tebibytes_sec,
4054    #[serde(rename = "tebibits_sec")]
4055    Tebibits_sec,
4056    #[serde(rename = "terabytes_sec")]
4057    Terabytes_sec,
4058    #[serde(rename = "terabits_sec")]
4059    Terabits_sec,
4060    #[serde(rename = "pebibytes_sec")]
4061    Pebibytes_sec,
4062    #[serde(rename = "pebibits_sec")]
4063    Pebibits_sec,
4064    #[serde(rename = "petabytes_sec")]
4065    Petabytes_sec,
4066    #[serde(rename = "petabits_sec")]
4067    Petabits_sec,
4068    #[serde(rename = "cps")]
4069    Cps,
4070    #[serde(rename = "ops")]
4071    Ops,
4072    #[serde(rename = "rps")]
4073    Rps,
4074    #[serde(rename = "reads_sec")]
4075    Reads_sec,
4076    #[serde(rename = "wps")]
4077    Wps,
4078    #[serde(rename = "iops")]
4079    Iops,
4080    #[serde(rename = "cpm")]
4081    Cpm,
4082    #[serde(rename = "opm")]
4083    Opm,
4084    #[serde(rename = "rpm_reads")]
4085    Rpm_reads,
4086    #[serde(rename = "wpm")]
4087    Wpm,
4088    /// Catch-all for unknown or newly-added values.
4089    #[serde(untagged)]
4090    Unknown(String),
4091}
4092
4093impl std::fmt::Display for ClickStackNumberFormatNumericunit {
4094    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4095        match self {
4096            Self::Bytes_iec => write!(f, "bytes_iec"),
4097            Self::Bytes_si => write!(f, "bytes_si"),
4098            Self::Bits_iec => write!(f, "bits_iec"),
4099            Self::Bits_si => write!(f, "bits_si"),
4100            Self::Kibibytes => write!(f, "kibibytes"),
4101            Self::Kilobytes => write!(f, "kilobytes"),
4102            Self::Mebibytes => write!(f, "mebibytes"),
4103            Self::Megabytes => write!(f, "megabytes"),
4104            Self::Gibibytes => write!(f, "gibibytes"),
4105            Self::Gigabytes => write!(f, "gigabytes"),
4106            Self::Tebibytes => write!(f, "tebibytes"),
4107            Self::Terabytes => write!(f, "terabytes"),
4108            Self::Pebibytes => write!(f, "pebibytes"),
4109            Self::Petabytes => write!(f, "petabytes"),
4110            Self::Packets_sec => write!(f, "packets_sec"),
4111            Self::Bytes_sec_iec => write!(f, "bytes_sec_iec"),
4112            Self::Bytes_sec_si => write!(f, "bytes_sec_si"),
4113            Self::Bits_sec_iec => write!(f, "bits_sec_iec"),
4114            Self::Bits_sec_si => write!(f, "bits_sec_si"),
4115            Self::Kibibytes_sec => write!(f, "kibibytes_sec"),
4116            Self::Kibibits_sec => write!(f, "kibibits_sec"),
4117            Self::Kilobytes_sec => write!(f, "kilobytes_sec"),
4118            Self::Kilobits_sec => write!(f, "kilobits_sec"),
4119            Self::Mebibytes_sec => write!(f, "mebibytes_sec"),
4120            Self::Mebibits_sec => write!(f, "mebibits_sec"),
4121            Self::Megabytes_sec => write!(f, "megabytes_sec"),
4122            Self::Megabits_sec => write!(f, "megabits_sec"),
4123            Self::Gibibytes_sec => write!(f, "gibibytes_sec"),
4124            Self::Gibibits_sec => write!(f, "gibibits_sec"),
4125            Self::Gigabytes_sec => write!(f, "gigabytes_sec"),
4126            Self::Gigabits_sec => write!(f, "gigabits_sec"),
4127            Self::Tebibytes_sec => write!(f, "tebibytes_sec"),
4128            Self::Tebibits_sec => write!(f, "tebibits_sec"),
4129            Self::Terabytes_sec => write!(f, "terabytes_sec"),
4130            Self::Terabits_sec => write!(f, "terabits_sec"),
4131            Self::Pebibytes_sec => write!(f, "pebibytes_sec"),
4132            Self::Pebibits_sec => write!(f, "pebibits_sec"),
4133            Self::Petabytes_sec => write!(f, "petabytes_sec"),
4134            Self::Petabits_sec => write!(f, "petabits_sec"),
4135            Self::Cps => write!(f, "cps"),
4136            Self::Ops => write!(f, "ops"),
4137            Self::Rps => write!(f, "rps"),
4138            Self::Reads_sec => write!(f, "reads_sec"),
4139            Self::Wps => write!(f, "wps"),
4140            Self::Iops => write!(f, "iops"),
4141            Self::Cpm => write!(f, "cpm"),
4142            Self::Opm => write!(f, "opm"),
4143            Self::Rpm_reads => write!(f, "rpm_reads"),
4144            Self::Wpm => write!(f, "wpm"),
4145            Self::Unknown(s) => write!(f, "{s}"),
4146        }
4147    }
4148}
4149
4150/// Inline enum for `ClickStackNumberFormat.output`.
4151#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4152pub enum ClickStackNumberFormatOutput {
4153    #[serde(rename = "currency")]
4154    #[default]
4155    Currency,
4156    #[serde(rename = "percent")]
4157    Percent,
4158    #[serde(rename = "byte")]
4159    Byte,
4160    #[serde(rename = "time")]
4161    Time,
4162    #[serde(rename = "number")]
4163    Number,
4164    #[serde(rename = "data_rate")]
4165    Data_rate,
4166    #[serde(rename = "throughput")]
4167    Throughput,
4168    /// Catch-all for unknown or newly-added values.
4169    #[serde(untagged)]
4170    Unknown(String),
4171}
4172
4173impl std::fmt::Display for ClickStackNumberFormatOutput {
4174    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4175        match self {
4176            Self::Currency => write!(f, "currency"),
4177            Self::Percent => write!(f, "percent"),
4178            Self::Byte => write!(f, "byte"),
4179            Self::Time => write!(f, "time"),
4180            Self::Number => write!(f, "number"),
4181            Self::Data_rate => write!(f, "data_rate"),
4182            Self::Throughput => write!(f, "throughput"),
4183            Self::Unknown(s) => write!(f, "{s}"),
4184        }
4185    }
4186}
4187
4188/// Inline enum for `ClickStackNumberRawSqlChartConfig.configType`.
4189#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4190pub enum ClickStackNumberRawSqlChartConfigConfigtype {
4191    #[serde(rename = "sql")]
4192    #[default]
4193    Sql,
4194    /// Catch-all for unknown or newly-added values.
4195    #[serde(untagged)]
4196    Unknown(String),
4197}
4198
4199impl std::fmt::Display for ClickStackNumberRawSqlChartConfigConfigtype {
4200    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4201        match self {
4202            Self::Sql => write!(f, "sql"),
4203            Self::Unknown(s) => write!(f, "{s}"),
4204        }
4205    }
4206}
4207
4208/// Inline enum for `ClickStackNumberRawSqlChartConfig.displayType`.
4209#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4210pub enum ClickStackNumberRawSqlChartConfigDisplaytype {
4211    #[serde(rename = "number")]
4212    #[default]
4213    Number,
4214    /// Catch-all for unknown or newly-added values.
4215    #[serde(untagged)]
4216    Unknown(String),
4217}
4218
4219impl std::fmt::Display for ClickStackNumberRawSqlChartConfigDisplaytype {
4220    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4221        match self {
4222            Self::Number => write!(f, "number"),
4223            Self::Unknown(s) => write!(f, "{s}"),
4224        }
4225    }
4226}
4227
4228/// Inline enum for `ClickStackOnClickDashboard.type`.
4229#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4230pub enum ClickStackOnClickDashboardType {
4231    #[serde(rename = "dashboard")]
4232    #[default]
4233    Dashboard,
4234    /// Catch-all for unknown or newly-added values.
4235    #[serde(untagged)]
4236    Unknown(String),
4237}
4238
4239impl std::fmt::Display for ClickStackOnClickDashboardType {
4240    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4241        match self {
4242            Self::Dashboard => write!(f, "dashboard"),
4243            Self::Unknown(s) => write!(f, "{s}"),
4244        }
4245    }
4246}
4247
4248/// Inline enum for `ClickStackOnClickDashboard.whereLanguage`.
4249#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4250pub enum ClickStackOnClickDashboardWherelanguage {
4251    #[serde(rename = "sql")]
4252    #[default]
4253    Sql,
4254    #[serde(rename = "lucene")]
4255    Lucene,
4256    /// Catch-all for unknown or newly-added values.
4257    #[serde(untagged)]
4258    Unknown(String),
4259}
4260
4261impl std::fmt::Display for ClickStackOnClickDashboardWherelanguage {
4262    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4263        match self {
4264            Self::Sql => write!(f, "sql"),
4265            Self::Lucene => write!(f, "lucene"),
4266            Self::Unknown(s) => write!(f, "{s}"),
4267        }
4268    }
4269}
4270
4271/// Inline enum for `ClickStackOnClickFilterTemplate.kind`.
4272#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4273pub enum ClickStackOnClickFilterTemplateKind {
4274    #[serde(rename = "expressionTemplate")]
4275    #[default]
4276    ExpressionTemplate,
4277    /// Catch-all for unknown or newly-added values.
4278    #[serde(untagged)]
4279    Unknown(String),
4280}
4281
4282impl std::fmt::Display for ClickStackOnClickFilterTemplateKind {
4283    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4284        match self {
4285            Self::ExpressionTemplate => write!(f, "expressionTemplate"),
4286            Self::Unknown(s) => write!(f, "{s}"),
4287        }
4288    }
4289}
4290
4291/// Inline enum for `ClickStackOnClickSearch.type`.
4292#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4293pub enum ClickStackOnClickSearchType {
4294    #[serde(rename = "search")]
4295    #[default]
4296    Search,
4297    /// Catch-all for unknown or newly-added values.
4298    #[serde(untagged)]
4299    Unknown(String),
4300}
4301
4302impl std::fmt::Display for ClickStackOnClickSearchType {
4303    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4304        match self {
4305            Self::Search => write!(f, "search"),
4306            Self::Unknown(s) => write!(f, "{s}"),
4307        }
4308    }
4309}
4310
4311/// Inline enum for `ClickStackOnClickSearch.whereLanguage`.
4312#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4313pub enum ClickStackOnClickSearchWherelanguage {
4314    #[serde(rename = "sql")]
4315    #[default]
4316    Sql,
4317    #[serde(rename = "lucene")]
4318    Lucene,
4319    /// Catch-all for unknown or newly-added values.
4320    #[serde(untagged)]
4321    Unknown(String),
4322}
4323
4324impl std::fmt::Display for ClickStackOnClickSearchWherelanguage {
4325    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4326        match self {
4327            Self::Sql => write!(f, "sql"),
4328            Self::Lucene => write!(f, "lucene"),
4329            Self::Unknown(s) => write!(f, "{s}"),
4330        }
4331    }
4332}
4333
4334/// Inline enum for `ClickStackOnClickTargetIdVariant.mode`.
4335#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4336pub enum ClickStackOnClickTargetIdVariantMode {
4337    #[serde(rename = "id")]
4338    #[default]
4339    Id,
4340    /// Catch-all for unknown or newly-added values.
4341    #[serde(untagged)]
4342    Unknown(String),
4343}
4344
4345impl std::fmt::Display for ClickStackOnClickTargetIdVariantMode {
4346    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4347        match self {
4348            Self::Id => write!(f, "id"),
4349            Self::Unknown(s) => write!(f, "{s}"),
4350        }
4351    }
4352}
4353
4354/// Inline enum for `ClickStackOnClickTargetTemplateVariant.mode`.
4355#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4356pub enum ClickStackOnClickTargetTemplateVariantMode {
4357    #[serde(rename = "template")]
4358    #[default]
4359    Template,
4360    /// Catch-all for unknown or newly-added values.
4361    #[serde(untagged)]
4362    Unknown(String),
4363}
4364
4365impl std::fmt::Display for ClickStackOnClickTargetTemplateVariantMode {
4366    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4367        match self {
4368            Self::Template => write!(f, "template"),
4369            Self::Unknown(s) => write!(f, "{s}"),
4370        }
4371    }
4372}
4373
4374/// Inline enum for `ClickStackPagerDutyAPIWebhook.service`.
4375#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4376pub enum ClickStackPagerDutyAPIWebhookService {
4377    #[serde(rename = "pagerduty_api")]
4378    #[default]
4379    Pagerduty_api,
4380    /// Catch-all for unknown or newly-added values.
4381    #[serde(untagged)]
4382    Unknown(String),
4383}
4384
4385impl std::fmt::Display for ClickStackPagerDutyAPIWebhookService {
4386    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4387        match self {
4388            Self::Pagerduty_api => write!(f, "pagerduty_api"),
4389            Self::Unknown(s) => write!(f, "{s}"),
4390        }
4391    }
4392}
4393
4394/// Inline enum for `ClickStackPieBuilderChartConfig.displayType`.
4395#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4396pub enum ClickStackPieBuilderChartConfigDisplaytype {
4397    #[serde(rename = "pie")]
4398    #[default]
4399    Pie,
4400    /// Catch-all for unknown or newly-added values.
4401    #[serde(untagged)]
4402    Unknown(String),
4403}
4404
4405impl std::fmt::Display for ClickStackPieBuilderChartConfigDisplaytype {
4406    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4407        match self {
4408            Self::Pie => write!(f, "pie"),
4409            Self::Unknown(s) => write!(f, "{s}"),
4410        }
4411    }
4412}
4413
4414/// Inline enum for `ClickStackPieRawSqlChartConfig.configType`.
4415#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4416pub enum ClickStackPieRawSqlChartConfigConfigtype {
4417    #[serde(rename = "sql")]
4418    #[default]
4419    Sql,
4420    /// Catch-all for unknown or newly-added values.
4421    #[serde(untagged)]
4422    Unknown(String),
4423}
4424
4425impl std::fmt::Display for ClickStackPieRawSqlChartConfigConfigtype {
4426    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4427        match self {
4428            Self::Sql => write!(f, "sql"),
4429            Self::Unknown(s) => write!(f, "{s}"),
4430        }
4431    }
4432}
4433
4434/// Inline enum for `ClickStackPieRawSqlChartConfig.displayType`.
4435#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4436pub enum ClickStackPieRawSqlChartConfigDisplaytype {
4437    #[serde(rename = "pie")]
4438    #[default]
4439    Pie,
4440    /// Catch-all for unknown or newly-added values.
4441    #[serde(untagged)]
4442    Unknown(String),
4443}
4444
4445impl std::fmt::Display for ClickStackPieRawSqlChartConfigDisplaytype {
4446    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4447        match self {
4448            Self::Pie => write!(f, "pie"),
4449            Self::Unknown(s) => write!(f, "{s}"),
4450        }
4451    }
4452}
4453
4454/// Inline enum for `ClickStackSavedFilterValue.type`.
4455#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4456pub enum ClickStackSavedFilterValueType {
4457    #[serde(rename = "sql")]
4458    #[default]
4459    Sql,
4460    /// Catch-all for unknown or newly-added values.
4461    #[serde(untagged)]
4462    Unknown(String),
4463}
4464
4465impl std::fmt::Display for ClickStackSavedFilterValueType {
4466    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4467        match self {
4468            Self::Sql => write!(f, "sql"),
4469            Self::Unknown(s) => write!(f, "{s}"),
4470        }
4471    }
4472}
4473
4474/// Inline enum for `ClickStackSearchChartConfig.displayType`.
4475#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4476pub enum ClickStackSearchChartConfigDisplaytype {
4477    #[serde(rename = "search")]
4478    #[default]
4479    Search,
4480    /// Catch-all for unknown or newly-added values.
4481    #[serde(untagged)]
4482    Unknown(String),
4483}
4484
4485impl std::fmt::Display for ClickStackSearchChartConfigDisplaytype {
4486    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4487        match self {
4488            Self::Search => write!(f, "search"),
4489            Self::Unknown(s) => write!(f, "{s}"),
4490        }
4491    }
4492}
4493
4494/// Inline enum for `ClickStackSearchChartConfig.whereLanguage`.
4495#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4496pub enum ClickStackSearchChartConfigWherelanguage {
4497    #[serde(rename = "sql")]
4498    #[default]
4499    Sql,
4500    #[serde(rename = "lucene")]
4501    Lucene,
4502    /// Catch-all for unknown or newly-added values.
4503    #[serde(untagged)]
4504    Unknown(String),
4505}
4506
4507impl std::fmt::Display for ClickStackSearchChartConfigWherelanguage {
4508    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4509        match self {
4510            Self::Sql => write!(f, "sql"),
4511            Self::Lucene => write!(f, "lucene"),
4512            Self::Unknown(s) => write!(f, "{s}"),
4513        }
4514    }
4515}
4516
4517/// Inline enum for `ClickStackSearchChartSeries.type`.
4518#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4519pub enum ClickStackSearchChartSeriesType {
4520    #[serde(rename = "search")]
4521    #[default]
4522    Search,
4523    /// Catch-all for unknown or newly-added values.
4524    #[serde(untagged)]
4525    Unknown(String),
4526}
4527
4528impl std::fmt::Display for ClickStackSearchChartSeriesType {
4529    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4530        match self {
4531            Self::Search => write!(f, "search"),
4532            Self::Unknown(s) => write!(f, "{s}"),
4533        }
4534    }
4535}
4536
4537/// Inline enum for `ClickStackSearchChartSeries.whereLanguage`.
4538#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4539pub enum ClickStackSearchChartSeriesWherelanguage {
4540    #[serde(rename = "sql")]
4541    #[default]
4542    Sql,
4543    #[serde(rename = "lucene")]
4544    Lucene,
4545    /// Catch-all for unknown or newly-added values.
4546    #[serde(untagged)]
4547    Unknown(String),
4548}
4549
4550impl std::fmt::Display for ClickStackSearchChartSeriesWherelanguage {
4551    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4552        match self {
4553            Self::Sql => write!(f, "sql"),
4554            Self::Lucene => write!(f, "lucene"),
4555            Self::Unknown(s) => write!(f, "{s}"),
4556        }
4557    }
4558}
4559
4560/// Inline enum for `ClickStackSelectItem.aggFn`.
4561#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4562pub enum ClickStackSelectItemAggfn {
4563    #[serde(rename = "avg")]
4564    #[default]
4565    Avg,
4566    #[serde(rename = "count")]
4567    Count,
4568    #[serde(rename = "count_distinct")]
4569    Count_distinct,
4570    #[serde(rename = "last_value")]
4571    Last_value,
4572    #[serde(rename = "max")]
4573    Max,
4574    #[serde(rename = "min")]
4575    Min,
4576    #[serde(rename = "quantile")]
4577    Quantile,
4578    #[serde(rename = "sum")]
4579    Sum,
4580    #[serde(rename = "any")]
4581    Any,
4582    #[serde(rename = "none")]
4583    None,
4584    /// Catch-all for unknown or newly-added values.
4585    #[serde(untagged)]
4586    Unknown(String),
4587}
4588
4589impl std::fmt::Display for ClickStackSelectItemAggfn {
4590    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4591        match self {
4592            Self::Avg => write!(f, "avg"),
4593            Self::Count => write!(f, "count"),
4594            Self::Count_distinct => write!(f, "count_distinct"),
4595            Self::Last_value => write!(f, "last_value"),
4596            Self::Max => write!(f, "max"),
4597            Self::Min => write!(f, "min"),
4598            Self::Quantile => write!(f, "quantile"),
4599            Self::Sum => write!(f, "sum"),
4600            Self::Any => write!(f, "any"),
4601            Self::None => write!(f, "none"),
4602            Self::Unknown(s) => write!(f, "{s}"),
4603        }
4604    }
4605}
4606
4607/// Inline enum for `ClickStackSelectItem.level`.
4608#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4609pub enum ClickStackSelectItemLevel {
4610    #[serde(rename = "0.5")]
4611    #[default]
4612    _0_5,
4613    #[serde(rename = "0.9")]
4614    _0_9,
4615    #[serde(rename = "0.95")]
4616    _0_95,
4617    #[serde(rename = "0.99")]
4618    _0_99,
4619    /// Catch-all for unknown or newly-added values.
4620    #[serde(untagged)]
4621    Unknown(String),
4622}
4623
4624impl std::fmt::Display for ClickStackSelectItemLevel {
4625    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4626        match self {
4627            Self::_0_5 => write!(f, "0.5"),
4628            Self::_0_9 => write!(f, "0.9"),
4629            Self::_0_95 => write!(f, "0.95"),
4630            Self::_0_99 => write!(f, "0.99"),
4631            Self::Unknown(s) => write!(f, "{s}"),
4632        }
4633    }
4634}
4635
4636/// Inline enum for `ClickStackSelectItem.metricType`.
4637#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4638pub enum ClickStackSelectItemMetrictype {
4639    #[serde(rename = "sum")]
4640    #[default]
4641    Sum,
4642    #[serde(rename = "gauge")]
4643    Gauge,
4644    #[serde(rename = "histogram")]
4645    Histogram,
4646    #[serde(rename = "summary")]
4647    Summary,
4648    #[serde(rename = "exponential histogram")]
4649    Exponential_histogram,
4650    /// Catch-all for unknown or newly-added values.
4651    #[serde(untagged)]
4652    Unknown(String),
4653}
4654
4655impl std::fmt::Display for ClickStackSelectItemMetrictype {
4656    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4657        match self {
4658            Self::Sum => write!(f, "sum"),
4659            Self::Gauge => write!(f, "gauge"),
4660            Self::Histogram => write!(f, "histogram"),
4661            Self::Summary => write!(f, "summary"),
4662            Self::Exponential_histogram => write!(f, "exponential histogram"),
4663            Self::Unknown(s) => write!(f, "{s}"),
4664        }
4665    }
4666}
4667
4668/// Inline enum for `ClickStackSelectItem.periodAggFn`.
4669#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4670pub enum ClickStackSelectItemPeriodaggfn {
4671    #[serde(rename = "delta")]
4672    #[default]
4673    Delta,
4674    /// Catch-all for unknown or newly-added values.
4675    #[serde(untagged)]
4676    Unknown(String),
4677}
4678
4679impl std::fmt::Display for ClickStackSelectItemPeriodaggfn {
4680    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4681        match self {
4682            Self::Delta => write!(f, "delta"),
4683            Self::Unknown(s) => write!(f, "{s}"),
4684        }
4685    }
4686}
4687
4688/// Inline enum for `ClickStackSelectItem.whereLanguage`.
4689#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4690pub enum ClickStackSelectItemWherelanguage {
4691    #[serde(rename = "sql")]
4692    #[default]
4693    Sql,
4694    #[serde(rename = "lucene")]
4695    Lucene,
4696    /// Catch-all for unknown or newly-added values.
4697    #[serde(untagged)]
4698    Unknown(String),
4699}
4700
4701impl std::fmt::Display for ClickStackSelectItemWherelanguage {
4702    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4703        match self {
4704            Self::Sql => write!(f, "sql"),
4705            Self::Lucene => write!(f, "lucene"),
4706            Self::Unknown(s) => write!(f, "{s}"),
4707        }
4708    }
4709}
4710
4711/// Inline enum for `ClickStackSessionSource.kind`.
4712#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4713pub enum ClickStackSessionSourceKind {
4714    #[serde(rename = "session")]
4715    #[default]
4716    Session,
4717    /// Catch-all for unknown or newly-added values.
4718    #[serde(untagged)]
4719    Unknown(String),
4720}
4721
4722impl std::fmt::Display for ClickStackSessionSourceKind {
4723    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4724        match self {
4725            Self::Session => write!(f, "session"),
4726            Self::Unknown(s) => write!(f, "{s}"),
4727        }
4728    }
4729}
4730
4731/// Inline enum for `ClickStackSlackAPIWebhook.service`.
4732#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4733pub enum ClickStackSlackAPIWebhookService {
4734    #[serde(rename = "slack_api")]
4735    #[default]
4736    Slack_api,
4737    /// Catch-all for unknown or newly-added values.
4738    #[serde(untagged)]
4739    Unknown(String),
4740}
4741
4742impl std::fmt::Display for ClickStackSlackAPIWebhookService {
4743    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4744        match self {
4745            Self::Slack_api => write!(f, "slack_api"),
4746            Self::Unknown(s) => write!(f, "{s}"),
4747        }
4748    }
4749}
4750
4751/// Inline enum for `ClickStackSlackWebhook.service`.
4752#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4753pub enum ClickStackSlackWebhookService {
4754    #[serde(rename = "slack")]
4755    #[default]
4756    Slack,
4757    /// Catch-all for unknown or newly-added values.
4758    #[serde(untagged)]
4759    Unknown(String),
4760}
4761
4762impl std::fmt::Display for ClickStackSlackWebhookService {
4763    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4764        match self {
4765            Self::Slack => write!(f, "slack"),
4766            Self::Unknown(s) => write!(f, "{s}"),
4767        }
4768    }
4769}
4770
4771/// Inline enum for `ClickStackTableBuilderChartConfig.displayType`.
4772#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4773pub enum ClickStackTableBuilderChartConfigDisplaytype {
4774    #[serde(rename = "table")]
4775    #[default]
4776    Table,
4777    /// Catch-all for unknown or newly-added values.
4778    #[serde(untagged)]
4779    Unknown(String),
4780}
4781
4782impl std::fmt::Display for ClickStackTableBuilderChartConfigDisplaytype {
4783    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4784        match self {
4785            Self::Table => write!(f, "table"),
4786            Self::Unknown(s) => write!(f, "{s}"),
4787        }
4788    }
4789}
4790
4791/// Inline enum for `ClickStackTableChartSeries.aggFn`.
4792#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4793pub enum ClickStackTableChartSeriesAggfn {
4794    #[serde(rename = "avg")]
4795    #[default]
4796    Avg,
4797    #[serde(rename = "count")]
4798    Count,
4799    #[serde(rename = "count_distinct")]
4800    Count_distinct,
4801    #[serde(rename = "last_value")]
4802    Last_value,
4803    #[serde(rename = "max")]
4804    Max,
4805    #[serde(rename = "min")]
4806    Min,
4807    #[serde(rename = "quantile")]
4808    Quantile,
4809    #[serde(rename = "sum")]
4810    Sum,
4811    #[serde(rename = "any")]
4812    Any,
4813    #[serde(rename = "none")]
4814    None,
4815    /// Catch-all for unknown or newly-added values.
4816    #[serde(untagged)]
4817    Unknown(String),
4818}
4819
4820impl std::fmt::Display for ClickStackTableChartSeriesAggfn {
4821    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4822        match self {
4823            Self::Avg => write!(f, "avg"),
4824            Self::Count => write!(f, "count"),
4825            Self::Count_distinct => write!(f, "count_distinct"),
4826            Self::Last_value => write!(f, "last_value"),
4827            Self::Max => write!(f, "max"),
4828            Self::Min => write!(f, "min"),
4829            Self::Quantile => write!(f, "quantile"),
4830            Self::Sum => write!(f, "sum"),
4831            Self::Any => write!(f, "any"),
4832            Self::None => write!(f, "none"),
4833            Self::Unknown(s) => write!(f, "{s}"),
4834        }
4835    }
4836}
4837
4838/// Inline enum for `ClickStackTableChartSeries.metricDataType`.
4839#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4840pub enum ClickStackTableChartSeriesMetricdatatype {
4841    #[serde(rename = "sum")]
4842    #[default]
4843    Sum,
4844    #[serde(rename = "gauge")]
4845    Gauge,
4846    #[serde(rename = "histogram")]
4847    Histogram,
4848    #[serde(rename = "summary")]
4849    Summary,
4850    #[serde(rename = "exponential histogram")]
4851    Exponential_histogram,
4852    /// Catch-all for unknown or newly-added values.
4853    #[serde(untagged)]
4854    Unknown(String),
4855}
4856
4857impl std::fmt::Display for ClickStackTableChartSeriesMetricdatatype {
4858    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4859        match self {
4860            Self::Sum => write!(f, "sum"),
4861            Self::Gauge => write!(f, "gauge"),
4862            Self::Histogram => write!(f, "histogram"),
4863            Self::Summary => write!(f, "summary"),
4864            Self::Exponential_histogram => write!(f, "exponential histogram"),
4865            Self::Unknown(s) => write!(f, "{s}"),
4866        }
4867    }
4868}
4869
4870/// Inline enum for `ClickStackTableChartSeries.sortOrder`.
4871#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4872pub enum ClickStackTableChartSeriesSortorder {
4873    #[serde(rename = "desc")]
4874    #[default]
4875    Desc,
4876    #[serde(rename = "asc")]
4877    Asc,
4878    /// Catch-all for unknown or newly-added values.
4879    #[serde(untagged)]
4880    Unknown(String),
4881}
4882
4883impl std::fmt::Display for ClickStackTableChartSeriesSortorder {
4884    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4885        match self {
4886            Self::Desc => write!(f, "desc"),
4887            Self::Asc => write!(f, "asc"),
4888            Self::Unknown(s) => write!(f, "{s}"),
4889        }
4890    }
4891}
4892
4893/// Inline enum for `ClickStackTableChartSeries.type`.
4894#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4895pub enum ClickStackTableChartSeriesType {
4896    #[serde(rename = "table")]
4897    #[default]
4898    Table,
4899    /// Catch-all for unknown or newly-added values.
4900    #[serde(untagged)]
4901    Unknown(String),
4902}
4903
4904impl std::fmt::Display for ClickStackTableChartSeriesType {
4905    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4906        match self {
4907            Self::Table => write!(f, "table"),
4908            Self::Unknown(s) => write!(f, "{s}"),
4909        }
4910    }
4911}
4912
4913/// Inline enum for `ClickStackTableChartSeries.whereLanguage`.
4914#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4915pub enum ClickStackTableChartSeriesWherelanguage {
4916    #[serde(rename = "sql")]
4917    #[default]
4918    Sql,
4919    #[serde(rename = "lucene")]
4920    Lucene,
4921    /// Catch-all for unknown or newly-added values.
4922    #[serde(untagged)]
4923    Unknown(String),
4924}
4925
4926impl std::fmt::Display for ClickStackTableChartSeriesWherelanguage {
4927    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4928        match self {
4929            Self::Sql => write!(f, "sql"),
4930            Self::Lucene => write!(f, "lucene"),
4931            Self::Unknown(s) => write!(f, "{s}"),
4932        }
4933    }
4934}
4935
4936/// Inline enum for `ClickStackTableRawSqlChartConfig.configType`.
4937#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4938pub enum ClickStackTableRawSqlChartConfigConfigtype {
4939    #[serde(rename = "sql")]
4940    #[default]
4941    Sql,
4942    /// Catch-all for unknown or newly-added values.
4943    #[serde(untagged)]
4944    Unknown(String),
4945}
4946
4947impl std::fmt::Display for ClickStackTableRawSqlChartConfigConfigtype {
4948    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4949        match self {
4950            Self::Sql => write!(f, "sql"),
4951            Self::Unknown(s) => write!(f, "{s}"),
4952        }
4953    }
4954}
4955
4956/// Inline enum for `ClickStackTableRawSqlChartConfig.displayType`.
4957#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4958pub enum ClickStackTableRawSqlChartConfigDisplaytype {
4959    #[serde(rename = "table")]
4960    #[default]
4961    Table,
4962    /// Catch-all for unknown or newly-added values.
4963    #[serde(untagged)]
4964    Unknown(String),
4965}
4966
4967impl std::fmt::Display for ClickStackTableRawSqlChartConfigDisplaytype {
4968    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
4969        match self {
4970            Self::Table => write!(f, "table"),
4971            Self::Unknown(s) => write!(f, "{s}"),
4972        }
4973    }
4974}
4975
4976/// Inline enum for `ClickStackTimeChartSeries.aggFn`.
4977#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
4978pub enum ClickStackTimeChartSeriesAggfn {
4979    #[serde(rename = "avg")]
4980    #[default]
4981    Avg,
4982    #[serde(rename = "count")]
4983    Count,
4984    #[serde(rename = "count_distinct")]
4985    Count_distinct,
4986    #[serde(rename = "last_value")]
4987    Last_value,
4988    #[serde(rename = "max")]
4989    Max,
4990    #[serde(rename = "min")]
4991    Min,
4992    #[serde(rename = "quantile")]
4993    Quantile,
4994    #[serde(rename = "sum")]
4995    Sum,
4996    #[serde(rename = "any")]
4997    Any,
4998    #[serde(rename = "none")]
4999    None,
5000    /// Catch-all for unknown or newly-added values.
5001    #[serde(untagged)]
5002    Unknown(String),
5003}
5004
5005impl std::fmt::Display for ClickStackTimeChartSeriesAggfn {
5006    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5007        match self {
5008            Self::Avg => write!(f, "avg"),
5009            Self::Count => write!(f, "count"),
5010            Self::Count_distinct => write!(f, "count_distinct"),
5011            Self::Last_value => write!(f, "last_value"),
5012            Self::Max => write!(f, "max"),
5013            Self::Min => write!(f, "min"),
5014            Self::Quantile => write!(f, "quantile"),
5015            Self::Sum => write!(f, "sum"),
5016            Self::Any => write!(f, "any"),
5017            Self::None => write!(f, "none"),
5018            Self::Unknown(s) => write!(f, "{s}"),
5019        }
5020    }
5021}
5022
5023/// Inline enum for `ClickStackTimeChartSeries.displayType`.
5024#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5025pub enum ClickStackTimeChartSeriesDisplaytype {
5026    #[serde(rename = "stacked_bar")]
5027    #[default]
5028    Stacked_bar,
5029    #[serde(rename = "line")]
5030    Line,
5031    /// Catch-all for unknown or newly-added values.
5032    #[serde(untagged)]
5033    Unknown(String),
5034}
5035
5036impl std::fmt::Display for ClickStackTimeChartSeriesDisplaytype {
5037    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5038        match self {
5039            Self::Stacked_bar => write!(f, "stacked_bar"),
5040            Self::Line => write!(f, "line"),
5041            Self::Unknown(s) => write!(f, "{s}"),
5042        }
5043    }
5044}
5045
5046/// Inline enum for `ClickStackTimeChartSeries.metricDataType`.
5047#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5048pub enum ClickStackTimeChartSeriesMetricdatatype {
5049    #[serde(rename = "sum")]
5050    #[default]
5051    Sum,
5052    #[serde(rename = "gauge")]
5053    Gauge,
5054    #[serde(rename = "histogram")]
5055    Histogram,
5056    #[serde(rename = "summary")]
5057    Summary,
5058    #[serde(rename = "exponential histogram")]
5059    Exponential_histogram,
5060    /// Catch-all for unknown or newly-added values.
5061    #[serde(untagged)]
5062    Unknown(String),
5063}
5064
5065impl std::fmt::Display for ClickStackTimeChartSeriesMetricdatatype {
5066    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5067        match self {
5068            Self::Sum => write!(f, "sum"),
5069            Self::Gauge => write!(f, "gauge"),
5070            Self::Histogram => write!(f, "histogram"),
5071            Self::Summary => write!(f, "summary"),
5072            Self::Exponential_histogram => write!(f, "exponential histogram"),
5073            Self::Unknown(s) => write!(f, "{s}"),
5074        }
5075    }
5076}
5077
5078/// Inline enum for `ClickStackTimeChartSeries.type`.
5079#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5080pub enum ClickStackTimeChartSeriesType {
5081    #[serde(rename = "time")]
5082    #[default]
5083    Time,
5084    /// Catch-all for unknown or newly-added values.
5085    #[serde(untagged)]
5086    Unknown(String),
5087}
5088
5089impl std::fmt::Display for ClickStackTimeChartSeriesType {
5090    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5091        match self {
5092            Self::Time => write!(f, "time"),
5093            Self::Unknown(s) => write!(f, "{s}"),
5094        }
5095    }
5096}
5097
5098/// Inline enum for `ClickStackTimeChartSeries.whereLanguage`.
5099#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5100pub enum ClickStackTimeChartSeriesWherelanguage {
5101    #[serde(rename = "sql")]
5102    #[default]
5103    Sql,
5104    #[serde(rename = "lucene")]
5105    Lucene,
5106    /// Catch-all for unknown or newly-added values.
5107    #[serde(untagged)]
5108    Unknown(String),
5109}
5110
5111impl std::fmt::Display for ClickStackTimeChartSeriesWherelanguage {
5112    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5113        match self {
5114            Self::Sql => write!(f, "sql"),
5115            Self::Lucene => write!(f, "lucene"),
5116            Self::Unknown(s) => write!(f, "{s}"),
5117        }
5118    }
5119}
5120
5121/// Inline enum for `ClickStackTraceSource.kind`.
5122#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5123pub enum ClickStackTraceSourceKind {
5124    #[serde(rename = "trace")]
5125    #[default]
5126    Trace,
5127    /// Catch-all for unknown or newly-added values.
5128    #[serde(untagged)]
5129    Unknown(String),
5130}
5131
5132impl std::fmt::Display for ClickStackTraceSourceKind {
5133    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5134        match self {
5135            Self::Trace => write!(f, "trace"),
5136            Self::Unknown(s) => write!(f, "{s}"),
5137        }
5138    }
5139}
5140
5141/// Inline enum for `ClickStackUpdateAlertRequest.interval`.
5142#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5143pub enum ClickStackUpdateAlertRequestInterval {
5144    #[serde(rename = "1m")]
5145    #[default]
5146    _1m,
5147    #[serde(rename = "5m")]
5148    _5m,
5149    #[serde(rename = "15m")]
5150    _15m,
5151    #[serde(rename = "30m")]
5152    _30m,
5153    #[serde(rename = "1h")]
5154    _1h,
5155    #[serde(rename = "6h")]
5156    _6h,
5157    #[serde(rename = "12h")]
5158    _12h,
5159    #[serde(rename = "1d")]
5160    _1d,
5161    /// Catch-all for unknown or newly-added values.
5162    #[serde(untagged)]
5163    Unknown(String),
5164}
5165
5166impl std::fmt::Display for ClickStackUpdateAlertRequestInterval {
5167    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5168        match self {
5169            Self::_1m => write!(f, "1m"),
5170            Self::_5m => write!(f, "5m"),
5171            Self::_15m => write!(f, "15m"),
5172            Self::_30m => write!(f, "30m"),
5173            Self::_1h => write!(f, "1h"),
5174            Self::_6h => write!(f, "6h"),
5175            Self::_12h => write!(f, "12h"),
5176            Self::_1d => write!(f, "1d"),
5177            Self::Unknown(s) => write!(f, "{s}"),
5178        }
5179    }
5180}
5181
5182/// Inline enum for `ClickStackUpdateAlertRequest.source`.
5183#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5184pub enum ClickStackUpdateAlertRequestSource {
5185    #[serde(rename = "saved_search")]
5186    #[default]
5187    Saved_search,
5188    #[serde(rename = "tile")]
5189    Tile,
5190    /// Catch-all for unknown or newly-added values.
5191    #[serde(untagged)]
5192    Unknown(String),
5193}
5194
5195impl std::fmt::Display for ClickStackUpdateAlertRequestSource {
5196    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5197        match self {
5198            Self::Saved_search => write!(f, "saved_search"),
5199            Self::Tile => write!(f, "tile"),
5200            Self::Unknown(s) => write!(f, "{s}"),
5201        }
5202    }
5203}
5204
5205/// Inline enum for `ClickStackUpdateAlertRequest.thresholdType`.
5206#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5207pub enum ClickStackUpdateAlertRequestThresholdtype {
5208    #[serde(rename = "above")]
5209    #[default]
5210    Above,
5211    #[serde(rename = "below")]
5212    Below,
5213    /// Catch-all for unknown or newly-added values.
5214    #[serde(untagged)]
5215    Unknown(String),
5216}
5217
5218impl std::fmt::Display for ClickStackUpdateAlertRequestThresholdtype {
5219    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5220        match self {
5221            Self::Above => write!(f, "above"),
5222            Self::Below => write!(f, "below"),
5223            Self::Unknown(s) => write!(f, "{s}"),
5224        }
5225    }
5226}
5227
5228/// Inline enum for `ClickStackUpdateDashboardRequest.savedQueryLanguage`.
5229#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5230pub enum ClickStackUpdateDashboardRequestSavedquerylanguage {
5231    #[serde(rename = "sql")]
5232    #[default]
5233    Sql,
5234    #[serde(rename = "lucene")]
5235    Lucene,
5236    /// Catch-all for unknown or newly-added values.
5237    #[serde(untagged)]
5238    Unknown(String),
5239}
5240
5241impl std::fmt::Display for ClickStackUpdateDashboardRequestSavedquerylanguage {
5242    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5243        match self {
5244            Self::Sql => write!(f, "sql"),
5245            Self::Lucene => write!(f, "lucene"),
5246            Self::Unknown(s) => write!(f, "{s}"),
5247        }
5248    }
5249}
5250
5251/// Inline enum for `CreateReversePrivateEndpoint.mskAuthentication`.
5252#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5253pub enum CreateReversePrivateEndpointMskauthentication {
5254    #[default]
5255    SASL_IAM,
5256    SASL_SCRAM,
5257    /// Catch-all for unknown or newly-added values.
5258    #[serde(untagged)]
5259    Unknown(String),
5260}
5261
5262impl std::fmt::Display for CreateReversePrivateEndpointMskauthentication {
5263    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5264        match self {
5265            Self::SASL_IAM => write!(f, "SASL_IAM"),
5266            Self::SASL_SCRAM => write!(f, "SASL_SCRAM"),
5267            Self::Unknown(s) => write!(f, "{s}"),
5268        }
5269    }
5270}
5271
5272/// Inline enum for `CreateReversePrivateEndpoint.type`.
5273#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5274pub enum CreateReversePrivateEndpointType {
5275    #[default]
5276    VPC_ENDPOINT_SERVICE,
5277    VPC_RESOURCE,
5278    MSK_MULTI_VPC,
5279    /// Catch-all for unknown or newly-added values.
5280    #[serde(untagged)]
5281    Unknown(String),
5282}
5283
5284impl std::fmt::Display for CreateReversePrivateEndpointType {
5285    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5286        match self {
5287            Self::VPC_ENDPOINT_SERVICE => write!(f, "VPC_ENDPOINT_SERVICE"),
5288            Self::VPC_RESOURCE => write!(f, "VPC_RESOURCE"),
5289            Self::MSK_MULTI_VPC => write!(f, "MSK_MULTI_VPC"),
5290            Self::Unknown(s) => write!(f, "{s}"),
5291        }
5292    }
5293}
5294
5295/// Inline enum for `CurrentScaling.effectiveAutoscalingMode`.
5296#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5297pub enum CurrentScalingEffectiveautoscalingmode {
5298    #[serde(rename = "vertical")]
5299    #[default]
5300    Vertical,
5301    #[serde(rename = "horizontal")]
5302    Horizontal,
5303    /// Catch-all for unknown or newly-added values.
5304    #[serde(untagged)]
5305    Unknown(String),
5306}
5307
5308impl std::fmt::Display for CurrentScalingEffectiveautoscalingmode {
5309    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5310        match self {
5311            Self::Vertical => write!(f, "vertical"),
5312            Self::Horizontal => write!(f, "horizontal"),
5313            Self::Unknown(s) => write!(f, "{s}"),
5314        }
5315    }
5316}
5317
5318/// Inline enum for `GcpBackupBucket.bucketProvider`.
5319#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5320pub enum GcpBackupBucketBucketprovider {
5321    #[default]
5322    GCP,
5323    /// Catch-all for unknown or newly-added values.
5324    #[serde(untagged)]
5325    Unknown(String),
5326}
5327
5328impl std::fmt::Display for GcpBackupBucketBucketprovider {
5329    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5330        match self {
5331            Self::GCP => write!(f, "GCP"),
5332            Self::Unknown(s) => write!(f, "{s}"),
5333        }
5334    }
5335}
5336
5337/// Inline enum for `GcpBackupBucketPatchRequestV1.bucketProvider`.
5338#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5339pub enum GcpBackupBucketPatchRequestV1Bucketprovider {
5340    #[default]
5341    GCP,
5342    /// Catch-all for unknown or newly-added values.
5343    #[serde(untagged)]
5344    Unknown(String),
5345}
5346
5347impl std::fmt::Display for GcpBackupBucketPatchRequestV1Bucketprovider {
5348    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5349        match self {
5350            Self::GCP => write!(f, "GCP"),
5351            Self::Unknown(s) => write!(f, "{s}"),
5352        }
5353    }
5354}
5355
5356/// Inline enum for `GcpBackupBucketPostRequestV1.bucketProvider`.
5357#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5358pub enum GcpBackupBucketPostRequestV1Bucketprovider {
5359    #[default]
5360    GCP,
5361    /// Catch-all for unknown or newly-added values.
5362    #[serde(untagged)]
5363    Unknown(String),
5364}
5365
5366impl std::fmt::Display for GcpBackupBucketPostRequestV1Bucketprovider {
5367    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5368        match self {
5369            Self::GCP => write!(f, "GCP"),
5370            Self::Unknown(s) => write!(f, "{s}"),
5371        }
5372    }
5373}
5374
5375/// Inline enum for `GcpBackupBucketProperties.bucketProvider`.
5376#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5377pub enum GcpBackupBucketPropertiesBucketprovider {
5378    #[default]
5379    GCP,
5380    /// Catch-all for unknown or newly-added values.
5381    #[serde(untagged)]
5382    Unknown(String),
5383}
5384
5385impl std::fmt::Display for GcpBackupBucketPropertiesBucketprovider {
5386    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5387        match self {
5388            Self::GCP => write!(f, "GCP"),
5389            Self::Unknown(s) => write!(f, "{s}"),
5390        }
5391    }
5392}
5393
5394/// Inline enum for `InstancePrivateEndpoint.cloudProvider`.
5395#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5396pub enum InstancePrivateEndpointCloudprovider {
5397    #[serde(rename = "gcp")]
5398    #[default]
5399    Gcp,
5400    #[serde(rename = "aws")]
5401    Aws,
5402    #[serde(rename = "azure")]
5403    Azure,
5404    /// Catch-all for unknown or newly-added values.
5405    #[serde(untagged)]
5406    Unknown(String),
5407}
5408
5409impl std::fmt::Display for InstancePrivateEndpointCloudprovider {
5410    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5411        match self {
5412            Self::Gcp => write!(f, "gcp"),
5413            Self::Aws => write!(f, "aws"),
5414            Self::Azure => write!(f, "azure"),
5415            Self::Unknown(s) => write!(f, "{s}"),
5416        }
5417    }
5418}
5419
5420/// Inline enum for `InstancePrivateEndpoint.region`.
5421#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5422pub enum InstancePrivateEndpointRegion {
5423    #[serde(rename = "ap-northeast-1")]
5424    #[default]
5425    Ap_northeast_1,
5426    #[serde(rename = "ap-northeast-2")]
5427    Ap_northeast_2,
5428    #[serde(rename = "ap-south-1")]
5429    Ap_south_1,
5430    #[serde(rename = "ap-southeast-1")]
5431    Ap_southeast_1,
5432    #[serde(rename = "ap-southeast-2")]
5433    Ap_southeast_2,
5434    #[serde(rename = "eu-central-1")]
5435    Eu_central_1,
5436    #[serde(rename = "eu-west-1")]
5437    Eu_west_1,
5438    #[serde(rename = "eu-west-2")]
5439    Eu_west_2,
5440    #[serde(rename = "il-central-1")]
5441    Il_central_1,
5442    #[serde(rename = "us-east-1")]
5443    Us_east_1,
5444    #[serde(rename = "us-east-2")]
5445    Us_east_2,
5446    #[serde(rename = "us-west-2")]
5447    Us_west_2,
5448    #[serde(rename = "us-east1")]
5449    Us_east1,
5450    #[serde(rename = "us-central1")]
5451    Us_central1,
5452    #[serde(rename = "europe-west4")]
5453    Europe_west4,
5454    #[serde(rename = "asia-southeast1")]
5455    Asia_southeast1,
5456    #[serde(rename = "asia-northeast1")]
5457    Asia_northeast1,
5458    #[serde(rename = "eastus")]
5459    Eastus,
5460    #[serde(rename = "eastus2")]
5461    Eastus2,
5462    #[serde(rename = "westus3")]
5463    Westus3,
5464    #[serde(rename = "germanywestcentral")]
5465    Germanywestcentral,
5466    #[serde(rename = "centralus")]
5467    Centralus,
5468    /// Catch-all for unknown or newly-added values.
5469    #[serde(untagged)]
5470    Unknown(String),
5471}
5472
5473impl std::fmt::Display for InstancePrivateEndpointRegion {
5474    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5475        match self {
5476            Self::Ap_northeast_1 => write!(f, "ap-northeast-1"),
5477            Self::Ap_northeast_2 => write!(f, "ap-northeast-2"),
5478            Self::Ap_south_1 => write!(f, "ap-south-1"),
5479            Self::Ap_southeast_1 => write!(f, "ap-southeast-1"),
5480            Self::Ap_southeast_2 => write!(f, "ap-southeast-2"),
5481            Self::Eu_central_1 => write!(f, "eu-central-1"),
5482            Self::Eu_west_1 => write!(f, "eu-west-1"),
5483            Self::Eu_west_2 => write!(f, "eu-west-2"),
5484            Self::Il_central_1 => write!(f, "il-central-1"),
5485            Self::Us_east_1 => write!(f, "us-east-1"),
5486            Self::Us_east_2 => write!(f, "us-east-2"),
5487            Self::Us_west_2 => write!(f, "us-west-2"),
5488            Self::Us_east1 => write!(f, "us-east1"),
5489            Self::Us_central1 => write!(f, "us-central1"),
5490            Self::Europe_west4 => write!(f, "europe-west4"),
5491            Self::Asia_southeast1 => write!(f, "asia-southeast1"),
5492            Self::Asia_northeast1 => write!(f, "asia-northeast1"),
5493            Self::Eastus => write!(f, "eastus"),
5494            Self::Eastus2 => write!(f, "eastus2"),
5495            Self::Westus3 => write!(f, "westus3"),
5496            Self::Germanywestcentral => write!(f, "germanywestcentral"),
5497            Self::Centralus => write!(f, "centralus"),
5498            Self::Unknown(s) => write!(f, "{s}"),
5499        }
5500    }
5501}
5502
5503/// Inline enum for `Invitation.role`.
5504#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5505pub enum InvitationRole {
5506    #[serde(rename = "admin")]
5507    #[default]
5508    Admin,
5509    #[serde(rename = "developer")]
5510    Developer,
5511    /// Catch-all for unknown or newly-added values.
5512    #[serde(untagged)]
5513    Unknown(String),
5514}
5515
5516impl std::fmt::Display for InvitationRole {
5517    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5518        match self {
5519            Self::Admin => write!(f, "admin"),
5520            Self::Developer => write!(f, "developer"),
5521            Self::Unknown(s) => write!(f, "{s}"),
5522        }
5523    }
5524}
5525
5526/// Inline enum for `InvitationPostRequest.role`.
5527#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5528pub enum InvitationPostRequestRole {
5529    #[serde(rename = "admin")]
5530    #[default]
5531    Admin,
5532    #[serde(rename = "developer")]
5533    Developer,
5534    /// Catch-all for unknown or newly-added values.
5535    #[serde(untagged)]
5536    Unknown(String),
5537}
5538
5539impl std::fmt::Display for InvitationPostRequestRole {
5540    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5541        match self {
5542            Self::Admin => write!(f, "admin"),
5543            Self::Developer => write!(f, "developer"),
5544            Self::Unknown(s) => write!(f, "{s}"),
5545        }
5546    }
5547}
5548
5549/// Inline enum for `Member.role`.
5550#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5551pub enum MemberRole {
5552    #[serde(rename = "admin")]
5553    #[default]
5554    Admin,
5555    #[serde(rename = "developer")]
5556    Developer,
5557    /// Catch-all for unknown or newly-added values.
5558    #[serde(untagged)]
5559    Unknown(String),
5560}
5561
5562impl std::fmt::Display for MemberRole {
5563    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5564        match self {
5565            Self::Admin => write!(f, "admin"),
5566            Self::Developer => write!(f, "developer"),
5567            Self::Unknown(s) => write!(f, "{s}"),
5568        }
5569    }
5570}
5571
5572/// Inline enum for `MemberPatchRequest.role`.
5573#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5574pub enum MemberPatchRequestRole {
5575    #[serde(rename = "admin")]
5576    #[default]
5577    Admin,
5578    #[serde(rename = "developer")]
5579    Developer,
5580    /// Catch-all for unknown or newly-added values.
5581    #[serde(untagged)]
5582    Unknown(String),
5583}
5584
5585impl std::fmt::Display for MemberPatchRequestRole {
5586    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5587        match self {
5588            Self::Admin => write!(f, "admin"),
5589            Self::Developer => write!(f, "developer"),
5590            Self::Unknown(s) => write!(f, "{s}"),
5591        }
5592    }
5593}
5594
5595/// Inline enum for `OrganizationPatchPrivateEndpoint.cloudProvider`.
5596#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5597pub enum OrganizationPatchPrivateEndpointCloudprovider {
5598    #[serde(rename = "gcp")]
5599    #[default]
5600    Gcp,
5601    #[serde(rename = "aws")]
5602    Aws,
5603    #[serde(rename = "azure")]
5604    Azure,
5605    /// Catch-all for unknown or newly-added values.
5606    #[serde(untagged)]
5607    Unknown(String),
5608}
5609
5610impl std::fmt::Display for OrganizationPatchPrivateEndpointCloudprovider {
5611    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5612        match self {
5613            Self::Gcp => write!(f, "gcp"),
5614            Self::Aws => write!(f, "aws"),
5615            Self::Azure => write!(f, "azure"),
5616            Self::Unknown(s) => write!(f, "{s}"),
5617        }
5618    }
5619}
5620
5621/// Inline enum for `OrganizationPatchPrivateEndpoint.region`.
5622#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5623pub enum OrganizationPatchPrivateEndpointRegion {
5624    #[serde(rename = "ap-northeast-1")]
5625    #[default]
5626    Ap_northeast_1,
5627    #[serde(rename = "ap-northeast-2")]
5628    Ap_northeast_2,
5629    #[serde(rename = "ap-south-1")]
5630    Ap_south_1,
5631    #[serde(rename = "ap-southeast-1")]
5632    Ap_southeast_1,
5633    #[serde(rename = "ap-southeast-2")]
5634    Ap_southeast_2,
5635    #[serde(rename = "eu-central-1")]
5636    Eu_central_1,
5637    #[serde(rename = "eu-west-1")]
5638    Eu_west_1,
5639    #[serde(rename = "eu-west-2")]
5640    Eu_west_2,
5641    #[serde(rename = "il-central-1")]
5642    Il_central_1,
5643    #[serde(rename = "us-east-1")]
5644    Us_east_1,
5645    #[serde(rename = "us-east-2")]
5646    Us_east_2,
5647    #[serde(rename = "us-west-2")]
5648    Us_west_2,
5649    #[serde(rename = "us-east1")]
5650    Us_east1,
5651    #[serde(rename = "us-central1")]
5652    Us_central1,
5653    #[serde(rename = "europe-west4")]
5654    Europe_west4,
5655    #[serde(rename = "asia-southeast1")]
5656    Asia_southeast1,
5657    #[serde(rename = "asia-northeast1")]
5658    Asia_northeast1,
5659    #[serde(rename = "eastus")]
5660    Eastus,
5661    #[serde(rename = "eastus2")]
5662    Eastus2,
5663    #[serde(rename = "westus3")]
5664    Westus3,
5665    #[serde(rename = "germanywestcentral")]
5666    Germanywestcentral,
5667    #[serde(rename = "centralus")]
5668    Centralus,
5669    /// Catch-all for unknown or newly-added values.
5670    #[serde(untagged)]
5671    Unknown(String),
5672}
5673
5674impl std::fmt::Display for OrganizationPatchPrivateEndpointRegion {
5675    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5676        match self {
5677            Self::Ap_northeast_1 => write!(f, "ap-northeast-1"),
5678            Self::Ap_northeast_2 => write!(f, "ap-northeast-2"),
5679            Self::Ap_south_1 => write!(f, "ap-south-1"),
5680            Self::Ap_southeast_1 => write!(f, "ap-southeast-1"),
5681            Self::Ap_southeast_2 => write!(f, "ap-southeast-2"),
5682            Self::Eu_central_1 => write!(f, "eu-central-1"),
5683            Self::Eu_west_1 => write!(f, "eu-west-1"),
5684            Self::Eu_west_2 => write!(f, "eu-west-2"),
5685            Self::Il_central_1 => write!(f, "il-central-1"),
5686            Self::Us_east_1 => write!(f, "us-east-1"),
5687            Self::Us_east_2 => write!(f, "us-east-2"),
5688            Self::Us_west_2 => write!(f, "us-west-2"),
5689            Self::Us_east1 => write!(f, "us-east1"),
5690            Self::Us_central1 => write!(f, "us-central1"),
5691            Self::Europe_west4 => write!(f, "europe-west4"),
5692            Self::Asia_southeast1 => write!(f, "asia-southeast1"),
5693            Self::Asia_northeast1 => write!(f, "asia-northeast1"),
5694            Self::Eastus => write!(f, "eastus"),
5695            Self::Eastus2 => write!(f, "eastus2"),
5696            Self::Westus3 => write!(f, "westus3"),
5697            Self::Germanywestcentral => write!(f, "germanywestcentral"),
5698            Self::Centralus => write!(f, "centralus"),
5699            Self::Unknown(s) => write!(f, "{s}"),
5700        }
5701    }
5702}
5703
5704/// Inline enum for `OrganizationPrivateEndpoint.cloudProvider`.
5705#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5706pub enum OrganizationPrivateEndpointCloudprovider {
5707    #[serde(rename = "gcp")]
5708    #[default]
5709    Gcp,
5710    #[serde(rename = "aws")]
5711    Aws,
5712    #[serde(rename = "azure")]
5713    Azure,
5714    /// Catch-all for unknown or newly-added values.
5715    #[serde(untagged)]
5716    Unknown(String),
5717}
5718
5719impl std::fmt::Display for OrganizationPrivateEndpointCloudprovider {
5720    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5721        match self {
5722            Self::Gcp => write!(f, "gcp"),
5723            Self::Aws => write!(f, "aws"),
5724            Self::Azure => write!(f, "azure"),
5725            Self::Unknown(s) => write!(f, "{s}"),
5726        }
5727    }
5728}
5729
5730/// Inline enum for `OrganizationPrivateEndpoint.region`.
5731#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5732pub enum OrganizationPrivateEndpointRegion {
5733    #[serde(rename = "ap-northeast-1")]
5734    #[default]
5735    Ap_northeast_1,
5736    #[serde(rename = "ap-northeast-2")]
5737    Ap_northeast_2,
5738    #[serde(rename = "ap-south-1")]
5739    Ap_south_1,
5740    #[serde(rename = "ap-southeast-1")]
5741    Ap_southeast_1,
5742    #[serde(rename = "ap-southeast-2")]
5743    Ap_southeast_2,
5744    #[serde(rename = "eu-central-1")]
5745    Eu_central_1,
5746    #[serde(rename = "eu-west-1")]
5747    Eu_west_1,
5748    #[serde(rename = "eu-west-2")]
5749    Eu_west_2,
5750    #[serde(rename = "il-central-1")]
5751    Il_central_1,
5752    #[serde(rename = "us-east-1")]
5753    Us_east_1,
5754    #[serde(rename = "us-east-2")]
5755    Us_east_2,
5756    #[serde(rename = "us-west-2")]
5757    Us_west_2,
5758    #[serde(rename = "us-east1")]
5759    Us_east1,
5760    #[serde(rename = "us-central1")]
5761    Us_central1,
5762    #[serde(rename = "europe-west4")]
5763    Europe_west4,
5764    #[serde(rename = "asia-southeast1")]
5765    Asia_southeast1,
5766    #[serde(rename = "asia-northeast1")]
5767    Asia_northeast1,
5768    #[serde(rename = "eastus")]
5769    Eastus,
5770    #[serde(rename = "eastus2")]
5771    Eastus2,
5772    #[serde(rename = "westus3")]
5773    Westus3,
5774    #[serde(rename = "germanywestcentral")]
5775    Germanywestcentral,
5776    #[serde(rename = "centralus")]
5777    Centralus,
5778    /// Catch-all for unknown or newly-added values.
5779    #[serde(untagged)]
5780    Unknown(String),
5781}
5782
5783impl std::fmt::Display for OrganizationPrivateEndpointRegion {
5784    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5785        match self {
5786            Self::Ap_northeast_1 => write!(f, "ap-northeast-1"),
5787            Self::Ap_northeast_2 => write!(f, "ap-northeast-2"),
5788            Self::Ap_south_1 => write!(f, "ap-south-1"),
5789            Self::Ap_southeast_1 => write!(f, "ap-southeast-1"),
5790            Self::Ap_southeast_2 => write!(f, "ap-southeast-2"),
5791            Self::Eu_central_1 => write!(f, "eu-central-1"),
5792            Self::Eu_west_1 => write!(f, "eu-west-1"),
5793            Self::Eu_west_2 => write!(f, "eu-west-2"),
5794            Self::Il_central_1 => write!(f, "il-central-1"),
5795            Self::Us_east_1 => write!(f, "us-east-1"),
5796            Self::Us_east_2 => write!(f, "us-east-2"),
5797            Self::Us_west_2 => write!(f, "us-west-2"),
5798            Self::Us_east1 => write!(f, "us-east1"),
5799            Self::Us_central1 => write!(f, "us-central1"),
5800            Self::Europe_west4 => write!(f, "europe-west4"),
5801            Self::Asia_southeast1 => write!(f, "asia-southeast1"),
5802            Self::Asia_northeast1 => write!(f, "asia-northeast1"),
5803            Self::Eastus => write!(f, "eastus"),
5804            Self::Eastus2 => write!(f, "eastus2"),
5805            Self::Westus3 => write!(f, "westus3"),
5806            Self::Germanywestcentral => write!(f, "germanywestcentral"),
5807            Self::Centralus => write!(f, "centralus"),
5808            Self::Unknown(s) => write!(f, "{s}"),
5809        }
5810    }
5811}
5812
5813/// Inline enum for `PostgresServiceSetState.command`.
5814#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5815pub enum PostgresServiceSetStateCommand {
5816    #[serde(rename = "restart")]
5817    #[default]
5818    Restart,
5819    #[serde(rename = "promote")]
5820    Promote,
5821    #[serde(rename = "switchover")]
5822    Switchover,
5823    /// Catch-all for unknown or newly-added values.
5824    #[serde(untagged)]
5825    Unknown(String),
5826}
5827
5828impl std::fmt::Display for PostgresServiceSetStateCommand {
5829    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5830        match self {
5831            Self::Restart => write!(f, "restart"),
5832            Self::Promote => write!(f, "promote"),
5833            Self::Switchover => write!(f, "switchover"),
5834            Self::Unknown(s) => write!(f, "{s}"),
5835        }
5836    }
5837}
5838
5839/// Inline enum for `RBACPolicy.allowDeny`.
5840#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5841pub enum RBACPolicyAllowdeny {
5842    #[default]
5843    ALLOW,
5844    DENY,
5845    /// Catch-all for unknown or newly-added values.
5846    #[serde(untagged)]
5847    Unknown(String),
5848}
5849
5850impl std::fmt::Display for RBACPolicyAllowdeny {
5851    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5852        match self {
5853            Self::ALLOW => write!(f, "ALLOW"),
5854            Self::DENY => write!(f, "DENY"),
5855            Self::Unknown(s) => write!(f, "{s}"),
5856        }
5857    }
5858}
5859
5860/// Inline enum for `RBACPolicyCreateRequest.allowDeny`.
5861#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5862pub enum RBACPolicyCreateRequestAllowdeny {
5863    #[default]
5864    ALLOW,
5865    DENY,
5866    /// Catch-all for unknown or newly-added values.
5867    #[serde(untagged)]
5868    Unknown(String),
5869}
5870
5871impl std::fmt::Display for RBACPolicyCreateRequestAllowdeny {
5872    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5873        match self {
5874            Self::ALLOW => write!(f, "ALLOW"),
5875            Self::DENY => write!(f, "DENY"),
5876            Self::Unknown(s) => write!(f, "{s}"),
5877        }
5878    }
5879}
5880
5881/// Inline enum for `RBACPolicyTags.roleV2`.
5882#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5883pub enum RBACPolicyTagsRolev2 {
5884    #[serde(rename = "sql-console-readonly")]
5885    #[default]
5886    Sql_console_readonly,
5887    #[serde(rename = "sql-console-admin")]
5888    Sql_console_admin,
5889    /// Catch-all for unknown or newly-added values.
5890    #[serde(untagged)]
5891    Unknown(String),
5892}
5893
5894impl std::fmt::Display for RBACPolicyTagsRolev2 {
5895    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5896        match self {
5897            Self::Sql_console_readonly => write!(f, "sql-console-readonly"),
5898            Self::Sql_console_admin => write!(f, "sql-console-admin"),
5899            Self::Unknown(s) => write!(f, "{s}"),
5900        }
5901    }
5902}
5903
5904/// Inline enum for `RBACRole.type`.
5905#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5906pub enum RBACRoleType {
5907    #[serde(rename = "system")]
5908    #[default]
5909    System,
5910    #[serde(rename = "custom")]
5911    Custom,
5912    /// Catch-all for unknown or newly-added values.
5913    #[serde(untagged)]
5914    Unknown(String),
5915}
5916
5917impl std::fmt::Display for RBACRoleType {
5918    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5919        match self {
5920            Self::System => write!(f, "system"),
5921            Self::Custom => write!(f, "custom"),
5922            Self::Unknown(s) => write!(f, "{s}"),
5923        }
5924    }
5925}
5926
5927/// Inline enum for `ReversePrivateEndpoint.mskAuthentication`.
5928#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5929pub enum ReversePrivateEndpointMskauthentication {
5930    #[default]
5931    SASL_IAM,
5932    SASL_SCRAM,
5933    /// Catch-all for unknown or newly-added values.
5934    #[serde(untagged)]
5935    Unknown(String),
5936}
5937
5938impl std::fmt::Display for ReversePrivateEndpointMskauthentication {
5939    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5940        match self {
5941            Self::SASL_IAM => write!(f, "SASL_IAM"),
5942            Self::SASL_SCRAM => write!(f, "SASL_SCRAM"),
5943            Self::Unknown(s) => write!(f, "{s}"),
5944        }
5945    }
5946}
5947
5948/// Inline enum for `ReversePrivateEndpoint.status`.
5949#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5950pub enum ReversePrivateEndpointStatus {
5951    #[default]
5952    Unknown,
5953    Provisioning,
5954    Deleting,
5955    Ready,
5956    Failed,
5957    PendingAcceptance,
5958    Rejected,
5959    Expired,
5960    /// Catch-all for unknown or newly-added values.
5961    #[serde(untagged)]
5962    Other(String),
5963}
5964
5965impl std::fmt::Display for ReversePrivateEndpointStatus {
5966    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5967        match self {
5968            Self::Unknown => write!(f, "Unknown"),
5969            Self::Provisioning => write!(f, "Provisioning"),
5970            Self::Deleting => write!(f, "Deleting"),
5971            Self::Ready => write!(f, "Ready"),
5972            Self::Failed => write!(f, "Failed"),
5973            Self::PendingAcceptance => write!(f, "PendingAcceptance"),
5974            Self::Rejected => write!(f, "Rejected"),
5975            Self::Expired => write!(f, "Expired"),
5976            Self::Other(s) => write!(f, "{s}"),
5977        }
5978    }
5979}
5980
5981/// Inline enum for `ReversePrivateEndpoint.type`.
5982#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
5983pub enum ReversePrivateEndpointType {
5984    #[default]
5985    VPC_ENDPOINT_SERVICE,
5986    VPC_RESOURCE,
5987    MSK_MULTI_VPC,
5988    /// Catch-all for unknown or newly-added values.
5989    #[serde(untagged)]
5990    Unknown(String),
5991}
5992
5993impl std::fmt::Display for ReversePrivateEndpointType {
5994    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
5995        match self {
5996            Self::VPC_ENDPOINT_SERVICE => write!(f, "VPC_ENDPOINT_SERVICE"),
5997            Self::VPC_RESOURCE => write!(f, "VPC_RESOURCE"),
5998            Self::MSK_MULTI_VPC => write!(f, "MSK_MULTI_VPC"),
5999            Self::Unknown(s) => write!(f, "{s}"),
6000        }
6001    }
6002}
6003
6004/// Inline enum for `ScimPatchOperation.op`.
6005#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6006pub enum ScimPatchOperationOp {
6007    #[serde(rename = "add")]
6008    #[default]
6009    Add,
6010    #[serde(rename = "replace")]
6011    Replace,
6012    #[serde(rename = "remove")]
6013    Remove,
6014    /// Catch-all for unknown or newly-added values.
6015    #[serde(untagged)]
6016    Unknown(String),
6017}
6018
6019impl std::fmt::Display for ScimPatchOperationOp {
6020    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6021        match self {
6022            Self::Add => write!(f, "add"),
6023            Self::Replace => write!(f, "replace"),
6024            Self::Remove => write!(f, "remove"),
6025            Self::Unknown(s) => write!(f, "{s}"),
6026        }
6027    }
6028}
6029
6030/// Inline enum for `Service.complianceType`.
6031#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6032pub enum ServiceCompliancetype {
6033    #[serde(rename = "hipaa")]
6034    #[default]
6035    Hipaa,
6036    #[serde(rename = "pci")]
6037    Pci,
6038    /// Catch-all for unknown or newly-added values.
6039    #[serde(untagged)]
6040    Unknown(String),
6041}
6042
6043impl std::fmt::Display for ServiceCompliancetype {
6044    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6045        match self {
6046            Self::Hipaa => write!(f, "hipaa"),
6047            Self::Pci => write!(f, "pci"),
6048            Self::Unknown(s) => write!(f, "{s}"),
6049        }
6050    }
6051}
6052
6053/// Inline enum for `Service.profile`.
6054#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6055pub enum ServiceProfile {
6056    #[serde(rename = "v1-default")]
6057    #[default]
6058    V1_default,
6059    #[serde(rename = "v1-highmem-xs")]
6060    V1_highmem_xs,
6061    #[serde(rename = "v1-highmem-s")]
6062    V1_highmem_s,
6063    #[serde(rename = "v1-highmem-m")]
6064    V1_highmem_m,
6065    #[serde(rename = "v1-highmem-l")]
6066    V1_highmem_l,
6067    #[serde(rename = "v1-highmem-xl")]
6068    V1_highmem_xl,
6069    /// Catch-all for unknown or newly-added values.
6070    #[serde(untagged)]
6071    Unknown(String),
6072}
6073
6074impl std::fmt::Display for ServiceProfile {
6075    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6076        match self {
6077            Self::V1_default => write!(f, "v1-default"),
6078            Self::V1_highmem_xs => write!(f, "v1-highmem-xs"),
6079            Self::V1_highmem_s => write!(f, "v1-highmem-s"),
6080            Self::V1_highmem_m => write!(f, "v1-highmem-m"),
6081            Self::V1_highmem_l => write!(f, "v1-highmem-l"),
6082            Self::V1_highmem_xl => write!(f, "v1-highmem-xl"),
6083            Self::Unknown(s) => write!(f, "{s}"),
6084        }
6085    }
6086}
6087
6088/// Inline enum for `Service.provider`.
6089#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6090pub enum ServiceProvider {
6091    #[serde(rename = "aws")]
6092    #[default]
6093    Aws,
6094    #[serde(rename = "gcp")]
6095    Gcp,
6096    #[serde(rename = "azure")]
6097    Azure,
6098    /// Catch-all for unknown or newly-added values.
6099    #[serde(untagged)]
6100    Unknown(String),
6101}
6102
6103impl std::fmt::Display for ServiceProvider {
6104    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6105        match self {
6106            Self::Aws => write!(f, "aws"),
6107            Self::Gcp => write!(f, "gcp"),
6108            Self::Azure => write!(f, "azure"),
6109            Self::Unknown(s) => write!(f, "{s}"),
6110        }
6111    }
6112}
6113
6114/// Inline enum for `Service.region`.
6115#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6116pub enum ServiceRegion {
6117    #[serde(rename = "ap-northeast-1")]
6118    #[default]
6119    Ap_northeast_1,
6120    #[serde(rename = "ap-northeast-2")]
6121    Ap_northeast_2,
6122    #[serde(rename = "ap-south-1")]
6123    Ap_south_1,
6124    #[serde(rename = "ap-southeast-1")]
6125    Ap_southeast_1,
6126    #[serde(rename = "ap-southeast-2")]
6127    Ap_southeast_2,
6128    #[serde(rename = "eu-central-1")]
6129    Eu_central_1,
6130    #[serde(rename = "eu-west-1")]
6131    Eu_west_1,
6132    #[serde(rename = "eu-west-2")]
6133    Eu_west_2,
6134    #[serde(rename = "il-central-1")]
6135    Il_central_1,
6136    #[serde(rename = "us-east-1")]
6137    Us_east_1,
6138    #[serde(rename = "us-east-2")]
6139    Us_east_2,
6140    #[serde(rename = "us-west-2")]
6141    Us_west_2,
6142    #[serde(rename = "us-east1")]
6143    Us_east1,
6144    #[serde(rename = "us-central1")]
6145    Us_central1,
6146    #[serde(rename = "europe-west4")]
6147    Europe_west4,
6148    #[serde(rename = "asia-southeast1")]
6149    Asia_southeast1,
6150    #[serde(rename = "asia-northeast1")]
6151    Asia_northeast1,
6152    #[serde(rename = "eastus")]
6153    Eastus,
6154    #[serde(rename = "eastus2")]
6155    Eastus2,
6156    #[serde(rename = "westus3")]
6157    Westus3,
6158    #[serde(rename = "germanywestcentral")]
6159    Germanywestcentral,
6160    #[serde(rename = "centralus")]
6161    Centralus,
6162    /// Catch-all for unknown or newly-added values.
6163    #[serde(untagged)]
6164    Unknown(String),
6165}
6166
6167impl std::fmt::Display for ServiceRegion {
6168    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6169        match self {
6170            Self::Ap_northeast_1 => write!(f, "ap-northeast-1"),
6171            Self::Ap_northeast_2 => write!(f, "ap-northeast-2"),
6172            Self::Ap_south_1 => write!(f, "ap-south-1"),
6173            Self::Ap_southeast_1 => write!(f, "ap-southeast-1"),
6174            Self::Ap_southeast_2 => write!(f, "ap-southeast-2"),
6175            Self::Eu_central_1 => write!(f, "eu-central-1"),
6176            Self::Eu_west_1 => write!(f, "eu-west-1"),
6177            Self::Eu_west_2 => write!(f, "eu-west-2"),
6178            Self::Il_central_1 => write!(f, "il-central-1"),
6179            Self::Us_east_1 => write!(f, "us-east-1"),
6180            Self::Us_east_2 => write!(f, "us-east-2"),
6181            Self::Us_west_2 => write!(f, "us-west-2"),
6182            Self::Us_east1 => write!(f, "us-east1"),
6183            Self::Us_central1 => write!(f, "us-central1"),
6184            Self::Europe_west4 => write!(f, "europe-west4"),
6185            Self::Asia_southeast1 => write!(f, "asia-southeast1"),
6186            Self::Asia_northeast1 => write!(f, "asia-northeast1"),
6187            Self::Eastus => write!(f, "eastus"),
6188            Self::Eastus2 => write!(f, "eastus2"),
6189            Self::Westus3 => write!(f, "westus3"),
6190            Self::Germanywestcentral => write!(f, "germanywestcentral"),
6191            Self::Centralus => write!(f, "centralus"),
6192            Self::Unknown(s) => write!(f, "{s}"),
6193        }
6194    }
6195}
6196
6197/// Inline enum for `Service.releaseChannel`.
6198#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6199pub enum ServiceReleasechannel {
6200    #[serde(rename = "slow")]
6201    #[default]
6202    Slow,
6203    #[serde(rename = "default")]
6204    Default,
6205    #[serde(rename = "fast")]
6206    Fast,
6207    /// Catch-all for unknown or newly-added values.
6208    #[serde(untagged)]
6209    Unknown(String),
6210}
6211
6212impl std::fmt::Display for ServiceReleasechannel {
6213    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6214        match self {
6215            Self::Slow => write!(f, "slow"),
6216            Self::Default => write!(f, "default"),
6217            Self::Fast => write!(f, "fast"),
6218            Self::Unknown(s) => write!(f, "{s}"),
6219        }
6220    }
6221}
6222
6223/// Inline enum for `Service.state`.
6224#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6225pub enum ServiceState {
6226    #[serde(rename = "starting")]
6227    #[default]
6228    Starting,
6229    #[serde(rename = "stopping")]
6230    Stopping,
6231    #[serde(rename = "terminating")]
6232    Terminating,
6233    #[serde(rename = "softdeleting")]
6234    Softdeleting,
6235    #[serde(rename = "awaking")]
6236    Awaking,
6237    #[serde(rename = "partially_running")]
6238    Partially_running,
6239    #[serde(rename = "provisioning")]
6240    Provisioning,
6241    #[serde(rename = "running")]
6242    Running,
6243    #[serde(rename = "stopped")]
6244    Stopped,
6245    #[serde(rename = "terminated")]
6246    Terminated,
6247    #[serde(rename = "softdeleted")]
6248    Softdeleted,
6249    #[serde(rename = "degraded")]
6250    Degraded,
6251    #[serde(rename = "failed")]
6252    Failed,
6253    #[serde(rename = "idle")]
6254    Idle,
6255    /// Catch-all for unknown or newly-added values.
6256    #[serde(untagged)]
6257    Unknown(String),
6258}
6259
6260impl std::fmt::Display for ServiceState {
6261    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6262        match self {
6263            Self::Starting => write!(f, "starting"),
6264            Self::Stopping => write!(f, "stopping"),
6265            Self::Terminating => write!(f, "terminating"),
6266            Self::Softdeleting => write!(f, "softdeleting"),
6267            Self::Awaking => write!(f, "awaking"),
6268            Self::Partially_running => write!(f, "partially_running"),
6269            Self::Provisioning => write!(f, "provisioning"),
6270            Self::Running => write!(f, "running"),
6271            Self::Stopped => write!(f, "stopped"),
6272            Self::Terminated => write!(f, "terminated"),
6273            Self::Softdeleted => write!(f, "softdeleted"),
6274            Self::Degraded => write!(f, "degraded"),
6275            Self::Failed => write!(f, "failed"),
6276            Self::Idle => write!(f, "idle"),
6277            Self::Unknown(s) => write!(f, "{s}"),
6278        }
6279    }
6280}
6281
6282/// Inline enum for `Service.tier`.
6283#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6284pub enum ServiceTier {
6285    #[serde(rename = "development")]
6286    #[default]
6287    Development,
6288    #[serde(rename = "production")]
6289    Production,
6290    #[serde(rename = "dedicated_high_mem")]
6291    Dedicated_high_mem,
6292    #[serde(rename = "dedicated_high_cpu")]
6293    Dedicated_high_cpu,
6294    #[serde(rename = "dedicated_standard")]
6295    Dedicated_standard,
6296    #[serde(rename = "dedicated_standard_n2d_standard_4")]
6297    Dedicated_standard_n2d_standard_4,
6298    #[serde(rename = "dedicated_standard_n2d_standard_8")]
6299    Dedicated_standard_n2d_standard_8,
6300    #[serde(rename = "dedicated_standard_n2d_standard_32")]
6301    Dedicated_standard_n2d_standard_32,
6302    #[serde(rename = "dedicated_standard_n2d_standard_128")]
6303    Dedicated_standard_n2d_standard_128,
6304    #[serde(rename = "dedicated_standard_n2d_standard_32_16SSD")]
6305    Dedicated_standard_n2d_standard_32_16SSD,
6306    #[serde(rename = "dedicated_standard_n2d_standard_64_24SSD")]
6307    Dedicated_standard_n2d_standard_64_24SSD,
6308    /// Catch-all for unknown or newly-added values.
6309    #[serde(untagged)]
6310    Unknown(String),
6311}
6312
6313impl std::fmt::Display for ServiceTier {
6314    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6315        match self {
6316            Self::Development => write!(f, "development"),
6317            Self::Production => write!(f, "production"),
6318            Self::Dedicated_high_mem => write!(f, "dedicated_high_mem"),
6319            Self::Dedicated_high_cpu => write!(f, "dedicated_high_cpu"),
6320            Self::Dedicated_standard => write!(f, "dedicated_standard"),
6321            Self::Dedicated_standard_n2d_standard_4 => write!(f, "dedicated_standard_n2d_standard_4"),
6322            Self::Dedicated_standard_n2d_standard_8 => write!(f, "dedicated_standard_n2d_standard_8"),
6323            Self::Dedicated_standard_n2d_standard_32 => write!(f, "dedicated_standard_n2d_standard_32"),
6324            Self::Dedicated_standard_n2d_standard_128 => write!(f, "dedicated_standard_n2d_standard_128"),
6325            Self::Dedicated_standard_n2d_standard_32_16SSD => write!(f, "dedicated_standard_n2d_standard_32_16SSD"),
6326            Self::Dedicated_standard_n2d_standard_64_24SSD => write!(f, "dedicated_standard_n2d_standard_64_24SSD"),
6327            Self::Unknown(s) => write!(f, "{s}"),
6328        }
6329    }
6330}
6331
6332/// Inline enum for `ServiceEndpoint.protocol`.
6333#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6334pub enum ServiceEndpointProtocol {
6335    #[serde(rename = "https")]
6336    #[default]
6337    Https,
6338    #[serde(rename = "nativesecure")]
6339    Nativesecure,
6340    #[serde(rename = "mysql")]
6341    Mysql,
6342    /// Catch-all for unknown or newly-added values.
6343    #[serde(untagged)]
6344    Unknown(String),
6345}
6346
6347impl std::fmt::Display for ServiceEndpointProtocol {
6348    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6349        match self {
6350            Self::Https => write!(f, "https"),
6351            Self::Nativesecure => write!(f, "nativesecure"),
6352            Self::Mysql => write!(f, "mysql"),
6353            Self::Unknown(s) => write!(f, "{s}"),
6354        }
6355    }
6356}
6357
6358/// Inline enum for `ServiceEndpointChange.protocol`.
6359#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6360pub enum ServiceEndpointChangeProtocol {
6361    #[serde(rename = "mysql")]
6362    #[default]
6363    Mysql,
6364    /// Catch-all for unknown or newly-added values.
6365    #[serde(untagged)]
6366    Unknown(String),
6367}
6368
6369impl std::fmt::Display for ServiceEndpointChangeProtocol {
6370    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6371        match self {
6372            Self::Mysql => write!(f, "mysql"),
6373            Self::Unknown(s) => write!(f, "{s}"),
6374        }
6375    }
6376}
6377
6378/// Inline enum for `ServicePatchRequest.releaseChannel`.
6379#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6380pub enum ServicePatchRequestReleasechannel {
6381    #[serde(rename = "slow")]
6382    #[default]
6383    Slow,
6384    #[serde(rename = "default")]
6385    Default,
6386    #[serde(rename = "fast")]
6387    Fast,
6388    /// Catch-all for unknown or newly-added values.
6389    #[serde(untagged)]
6390    Unknown(String),
6391}
6392
6393impl std::fmt::Display for ServicePatchRequestReleasechannel {
6394    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6395        match self {
6396            Self::Slow => write!(f, "slow"),
6397            Self::Default => write!(f, "default"),
6398            Self::Fast => write!(f, "fast"),
6399            Self::Unknown(s) => write!(f, "{s}"),
6400        }
6401    }
6402}
6403
6404/// Inline enum for `ServicePostRequest.complianceType`.
6405#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6406pub enum ServicePostRequestCompliancetype {
6407    #[serde(rename = "hipaa")]
6408    #[default]
6409    Hipaa,
6410    #[serde(rename = "pci")]
6411    Pci,
6412    /// Catch-all for unknown or newly-added values.
6413    #[serde(untagged)]
6414    Unknown(String),
6415}
6416
6417impl std::fmt::Display for ServicePostRequestCompliancetype {
6418    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6419        match self {
6420            Self::Hipaa => write!(f, "hipaa"),
6421            Self::Pci => write!(f, "pci"),
6422            Self::Unknown(s) => write!(f, "{s}"),
6423        }
6424    }
6425}
6426
6427/// Inline enum for `ServicePostRequest.profile`.
6428#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6429pub enum ServicePostRequestProfile {
6430    #[serde(rename = "v1-default")]
6431    #[default]
6432    V1_default,
6433    #[serde(rename = "v1-highmem-xs")]
6434    V1_highmem_xs,
6435    #[serde(rename = "v1-highmem-s")]
6436    V1_highmem_s,
6437    #[serde(rename = "v1-highmem-m")]
6438    V1_highmem_m,
6439    #[serde(rename = "v1-highmem-l")]
6440    V1_highmem_l,
6441    #[serde(rename = "v1-highmem-xl")]
6442    V1_highmem_xl,
6443    /// Catch-all for unknown or newly-added values.
6444    #[serde(untagged)]
6445    Unknown(String),
6446}
6447
6448impl std::fmt::Display for ServicePostRequestProfile {
6449    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6450        match self {
6451            Self::V1_default => write!(f, "v1-default"),
6452            Self::V1_highmem_xs => write!(f, "v1-highmem-xs"),
6453            Self::V1_highmem_s => write!(f, "v1-highmem-s"),
6454            Self::V1_highmem_m => write!(f, "v1-highmem-m"),
6455            Self::V1_highmem_l => write!(f, "v1-highmem-l"),
6456            Self::V1_highmem_xl => write!(f, "v1-highmem-xl"),
6457            Self::Unknown(s) => write!(f, "{s}"),
6458        }
6459    }
6460}
6461
6462/// Inline enum for `ServicePostRequest.provider`.
6463#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6464pub enum ServicePostRequestProvider {
6465    #[serde(rename = "aws")]
6466    #[default]
6467    Aws,
6468    #[serde(rename = "gcp")]
6469    Gcp,
6470    #[serde(rename = "azure")]
6471    Azure,
6472    /// Catch-all for unknown or newly-added values.
6473    #[serde(untagged)]
6474    Unknown(String),
6475}
6476
6477impl std::fmt::Display for ServicePostRequestProvider {
6478    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6479        match self {
6480            Self::Aws => write!(f, "aws"),
6481            Self::Gcp => write!(f, "gcp"),
6482            Self::Azure => write!(f, "azure"),
6483            Self::Unknown(s) => write!(f, "{s}"),
6484        }
6485    }
6486}
6487
6488/// Inline enum for `ServicePostRequest.region`.
6489#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6490pub enum ServicePostRequestRegion {
6491    #[serde(rename = "ap-northeast-1")]
6492    #[default]
6493    Ap_northeast_1,
6494    #[serde(rename = "ap-northeast-2")]
6495    Ap_northeast_2,
6496    #[serde(rename = "ap-south-1")]
6497    Ap_south_1,
6498    #[serde(rename = "ap-southeast-1")]
6499    Ap_southeast_1,
6500    #[serde(rename = "ap-southeast-2")]
6501    Ap_southeast_2,
6502    #[serde(rename = "eu-central-1")]
6503    Eu_central_1,
6504    #[serde(rename = "eu-west-1")]
6505    Eu_west_1,
6506    #[serde(rename = "eu-west-2")]
6507    Eu_west_2,
6508    #[serde(rename = "il-central-1")]
6509    Il_central_1,
6510    #[serde(rename = "us-east-1")]
6511    Us_east_1,
6512    #[serde(rename = "us-east-2")]
6513    Us_east_2,
6514    #[serde(rename = "us-west-2")]
6515    Us_west_2,
6516    #[serde(rename = "us-east1")]
6517    Us_east1,
6518    #[serde(rename = "us-central1")]
6519    Us_central1,
6520    #[serde(rename = "europe-west4")]
6521    Europe_west4,
6522    #[serde(rename = "asia-southeast1")]
6523    Asia_southeast1,
6524    #[serde(rename = "asia-northeast1")]
6525    Asia_northeast1,
6526    #[serde(rename = "eastus")]
6527    Eastus,
6528    #[serde(rename = "eastus2")]
6529    Eastus2,
6530    #[serde(rename = "westus3")]
6531    Westus3,
6532    #[serde(rename = "germanywestcentral")]
6533    Germanywestcentral,
6534    #[serde(rename = "centralus")]
6535    Centralus,
6536    /// Catch-all for unknown or newly-added values.
6537    #[serde(untagged)]
6538    Unknown(String),
6539}
6540
6541impl std::fmt::Display for ServicePostRequestRegion {
6542    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6543        match self {
6544            Self::Ap_northeast_1 => write!(f, "ap-northeast-1"),
6545            Self::Ap_northeast_2 => write!(f, "ap-northeast-2"),
6546            Self::Ap_south_1 => write!(f, "ap-south-1"),
6547            Self::Ap_southeast_1 => write!(f, "ap-southeast-1"),
6548            Self::Ap_southeast_2 => write!(f, "ap-southeast-2"),
6549            Self::Eu_central_1 => write!(f, "eu-central-1"),
6550            Self::Eu_west_1 => write!(f, "eu-west-1"),
6551            Self::Eu_west_2 => write!(f, "eu-west-2"),
6552            Self::Il_central_1 => write!(f, "il-central-1"),
6553            Self::Us_east_1 => write!(f, "us-east-1"),
6554            Self::Us_east_2 => write!(f, "us-east-2"),
6555            Self::Us_west_2 => write!(f, "us-west-2"),
6556            Self::Us_east1 => write!(f, "us-east1"),
6557            Self::Us_central1 => write!(f, "us-central1"),
6558            Self::Europe_west4 => write!(f, "europe-west4"),
6559            Self::Asia_southeast1 => write!(f, "asia-southeast1"),
6560            Self::Asia_northeast1 => write!(f, "asia-northeast1"),
6561            Self::Eastus => write!(f, "eastus"),
6562            Self::Eastus2 => write!(f, "eastus2"),
6563            Self::Westus3 => write!(f, "westus3"),
6564            Self::Germanywestcentral => write!(f, "germanywestcentral"),
6565            Self::Centralus => write!(f, "centralus"),
6566            Self::Unknown(s) => write!(f, "{s}"),
6567        }
6568    }
6569}
6570
6571/// Inline enum for `ServicePostRequest.releaseChannel`.
6572#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6573pub enum ServicePostRequestReleasechannel {
6574    #[serde(rename = "slow")]
6575    #[default]
6576    Slow,
6577    #[serde(rename = "default")]
6578    Default,
6579    #[serde(rename = "fast")]
6580    Fast,
6581    /// Catch-all for unknown or newly-added values.
6582    #[serde(untagged)]
6583    Unknown(String),
6584}
6585
6586impl std::fmt::Display for ServicePostRequestReleasechannel {
6587    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6588        match self {
6589            Self::Slow => write!(f, "slow"),
6590            Self::Default => write!(f, "default"),
6591            Self::Fast => write!(f, "fast"),
6592            Self::Unknown(s) => write!(f, "{s}"),
6593        }
6594    }
6595}
6596
6597/// Inline enum for `ServicePostRequest.tier`.
6598#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6599pub enum ServicePostRequestTier {
6600    #[serde(rename = "development")]
6601    #[default]
6602    Development,
6603    #[serde(rename = "production")]
6604    Production,
6605    #[serde(rename = "dedicated_high_mem")]
6606    Dedicated_high_mem,
6607    #[serde(rename = "dedicated_high_cpu")]
6608    Dedicated_high_cpu,
6609    #[serde(rename = "dedicated_standard")]
6610    Dedicated_standard,
6611    #[serde(rename = "dedicated_standard_n2d_standard_4")]
6612    Dedicated_standard_n2d_standard_4,
6613    #[serde(rename = "dedicated_standard_n2d_standard_8")]
6614    Dedicated_standard_n2d_standard_8,
6615    #[serde(rename = "dedicated_standard_n2d_standard_32")]
6616    Dedicated_standard_n2d_standard_32,
6617    #[serde(rename = "dedicated_standard_n2d_standard_128")]
6618    Dedicated_standard_n2d_standard_128,
6619    #[serde(rename = "dedicated_standard_n2d_standard_32_16SSD")]
6620    Dedicated_standard_n2d_standard_32_16SSD,
6621    #[serde(rename = "dedicated_standard_n2d_standard_64_24SSD")]
6622    Dedicated_standard_n2d_standard_64_24SSD,
6623    /// Catch-all for unknown or newly-added values.
6624    #[serde(untagged)]
6625    Unknown(String),
6626}
6627
6628impl std::fmt::Display for ServicePostRequestTier {
6629    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6630        match self {
6631            Self::Development => write!(f, "development"),
6632            Self::Production => write!(f, "production"),
6633            Self::Dedicated_high_mem => write!(f, "dedicated_high_mem"),
6634            Self::Dedicated_high_cpu => write!(f, "dedicated_high_cpu"),
6635            Self::Dedicated_standard => write!(f, "dedicated_standard"),
6636            Self::Dedicated_standard_n2d_standard_4 => write!(f, "dedicated_standard_n2d_standard_4"),
6637            Self::Dedicated_standard_n2d_standard_8 => write!(f, "dedicated_standard_n2d_standard_8"),
6638            Self::Dedicated_standard_n2d_standard_32 => write!(f, "dedicated_standard_n2d_standard_32"),
6639            Self::Dedicated_standard_n2d_standard_128 => write!(f, "dedicated_standard_n2d_standard_128"),
6640            Self::Dedicated_standard_n2d_standard_32_16SSD => write!(f, "dedicated_standard_n2d_standard_32_16SSD"),
6641            Self::Dedicated_standard_n2d_standard_64_24SSD => write!(f, "dedicated_standard_n2d_standard_64_24SSD"),
6642            Self::Unknown(s) => write!(f, "{s}"),
6643        }
6644    }
6645}
6646
6647/// Inline enum for `ServiceScalingPatchResponse.complianceType`.
6648#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6649pub enum ServiceScalingPatchResponseCompliancetype {
6650    #[serde(rename = "hipaa")]
6651    #[default]
6652    Hipaa,
6653    #[serde(rename = "pci")]
6654    Pci,
6655    /// Catch-all for unknown or newly-added values.
6656    #[serde(untagged)]
6657    Unknown(String),
6658}
6659
6660impl std::fmt::Display for ServiceScalingPatchResponseCompliancetype {
6661    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6662        match self {
6663            Self::Hipaa => write!(f, "hipaa"),
6664            Self::Pci => write!(f, "pci"),
6665            Self::Unknown(s) => write!(f, "{s}"),
6666        }
6667    }
6668}
6669
6670/// Inline enum for `ServiceScalingPatchResponse.profile`.
6671#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6672pub enum ServiceScalingPatchResponseProfile {
6673    #[serde(rename = "v1-default")]
6674    #[default]
6675    V1_default,
6676    #[serde(rename = "v1-highmem-xs")]
6677    V1_highmem_xs,
6678    #[serde(rename = "v1-highmem-s")]
6679    V1_highmem_s,
6680    #[serde(rename = "v1-highmem-m")]
6681    V1_highmem_m,
6682    #[serde(rename = "v1-highmem-l")]
6683    V1_highmem_l,
6684    #[serde(rename = "v1-highmem-xl")]
6685    V1_highmem_xl,
6686    /// Catch-all for unknown or newly-added values.
6687    #[serde(untagged)]
6688    Unknown(String),
6689}
6690
6691impl std::fmt::Display for ServiceScalingPatchResponseProfile {
6692    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6693        match self {
6694            Self::V1_default => write!(f, "v1-default"),
6695            Self::V1_highmem_xs => write!(f, "v1-highmem-xs"),
6696            Self::V1_highmem_s => write!(f, "v1-highmem-s"),
6697            Self::V1_highmem_m => write!(f, "v1-highmem-m"),
6698            Self::V1_highmem_l => write!(f, "v1-highmem-l"),
6699            Self::V1_highmem_xl => write!(f, "v1-highmem-xl"),
6700            Self::Unknown(s) => write!(f, "{s}"),
6701        }
6702    }
6703}
6704
6705/// Inline enum for `ServiceScalingPatchResponse.provider`.
6706#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6707pub enum ServiceScalingPatchResponseProvider {
6708    #[serde(rename = "aws")]
6709    #[default]
6710    Aws,
6711    #[serde(rename = "gcp")]
6712    Gcp,
6713    #[serde(rename = "azure")]
6714    Azure,
6715    /// Catch-all for unknown or newly-added values.
6716    #[serde(untagged)]
6717    Unknown(String),
6718}
6719
6720impl std::fmt::Display for ServiceScalingPatchResponseProvider {
6721    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6722        match self {
6723            Self::Aws => write!(f, "aws"),
6724            Self::Gcp => write!(f, "gcp"),
6725            Self::Azure => write!(f, "azure"),
6726            Self::Unknown(s) => write!(f, "{s}"),
6727        }
6728    }
6729}
6730
6731/// Inline enum for `ServiceScalingPatchResponse.region`.
6732#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6733pub enum ServiceScalingPatchResponseRegion {
6734    #[serde(rename = "ap-northeast-1")]
6735    #[default]
6736    Ap_northeast_1,
6737    #[serde(rename = "ap-northeast-2")]
6738    Ap_northeast_2,
6739    #[serde(rename = "ap-south-1")]
6740    Ap_south_1,
6741    #[serde(rename = "ap-southeast-1")]
6742    Ap_southeast_1,
6743    #[serde(rename = "ap-southeast-2")]
6744    Ap_southeast_2,
6745    #[serde(rename = "eu-central-1")]
6746    Eu_central_1,
6747    #[serde(rename = "eu-west-1")]
6748    Eu_west_1,
6749    #[serde(rename = "eu-west-2")]
6750    Eu_west_2,
6751    #[serde(rename = "il-central-1")]
6752    Il_central_1,
6753    #[serde(rename = "us-east-1")]
6754    Us_east_1,
6755    #[serde(rename = "us-east-2")]
6756    Us_east_2,
6757    #[serde(rename = "us-west-2")]
6758    Us_west_2,
6759    #[serde(rename = "us-east1")]
6760    Us_east1,
6761    #[serde(rename = "us-central1")]
6762    Us_central1,
6763    #[serde(rename = "europe-west4")]
6764    Europe_west4,
6765    #[serde(rename = "asia-southeast1")]
6766    Asia_southeast1,
6767    #[serde(rename = "asia-northeast1")]
6768    Asia_northeast1,
6769    #[serde(rename = "eastus")]
6770    Eastus,
6771    #[serde(rename = "eastus2")]
6772    Eastus2,
6773    #[serde(rename = "westus3")]
6774    Westus3,
6775    #[serde(rename = "germanywestcentral")]
6776    Germanywestcentral,
6777    #[serde(rename = "centralus")]
6778    Centralus,
6779    /// Catch-all for unknown or newly-added values.
6780    #[serde(untagged)]
6781    Unknown(String),
6782}
6783
6784impl std::fmt::Display for ServiceScalingPatchResponseRegion {
6785    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6786        match self {
6787            Self::Ap_northeast_1 => write!(f, "ap-northeast-1"),
6788            Self::Ap_northeast_2 => write!(f, "ap-northeast-2"),
6789            Self::Ap_south_1 => write!(f, "ap-south-1"),
6790            Self::Ap_southeast_1 => write!(f, "ap-southeast-1"),
6791            Self::Ap_southeast_2 => write!(f, "ap-southeast-2"),
6792            Self::Eu_central_1 => write!(f, "eu-central-1"),
6793            Self::Eu_west_1 => write!(f, "eu-west-1"),
6794            Self::Eu_west_2 => write!(f, "eu-west-2"),
6795            Self::Il_central_1 => write!(f, "il-central-1"),
6796            Self::Us_east_1 => write!(f, "us-east-1"),
6797            Self::Us_east_2 => write!(f, "us-east-2"),
6798            Self::Us_west_2 => write!(f, "us-west-2"),
6799            Self::Us_east1 => write!(f, "us-east1"),
6800            Self::Us_central1 => write!(f, "us-central1"),
6801            Self::Europe_west4 => write!(f, "europe-west4"),
6802            Self::Asia_southeast1 => write!(f, "asia-southeast1"),
6803            Self::Asia_northeast1 => write!(f, "asia-northeast1"),
6804            Self::Eastus => write!(f, "eastus"),
6805            Self::Eastus2 => write!(f, "eastus2"),
6806            Self::Westus3 => write!(f, "westus3"),
6807            Self::Germanywestcentral => write!(f, "germanywestcentral"),
6808            Self::Centralus => write!(f, "centralus"),
6809            Self::Unknown(s) => write!(f, "{s}"),
6810        }
6811    }
6812}
6813
6814/// Inline enum for `ServiceScalingPatchResponse.releaseChannel`.
6815#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6816pub enum ServiceScalingPatchResponseReleasechannel {
6817    #[serde(rename = "slow")]
6818    #[default]
6819    Slow,
6820    #[serde(rename = "default")]
6821    Default,
6822    #[serde(rename = "fast")]
6823    Fast,
6824    /// Catch-all for unknown or newly-added values.
6825    #[serde(untagged)]
6826    Unknown(String),
6827}
6828
6829impl std::fmt::Display for ServiceScalingPatchResponseReleasechannel {
6830    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6831        match self {
6832            Self::Slow => write!(f, "slow"),
6833            Self::Default => write!(f, "default"),
6834            Self::Fast => write!(f, "fast"),
6835            Self::Unknown(s) => write!(f, "{s}"),
6836        }
6837    }
6838}
6839
6840/// Inline enum for `ServiceScalingPatchResponse.state`.
6841#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6842pub enum ServiceScalingPatchResponseState {
6843    #[serde(rename = "starting")]
6844    #[default]
6845    Starting,
6846    #[serde(rename = "stopping")]
6847    Stopping,
6848    #[serde(rename = "terminating")]
6849    Terminating,
6850    #[serde(rename = "softdeleting")]
6851    Softdeleting,
6852    #[serde(rename = "awaking")]
6853    Awaking,
6854    #[serde(rename = "partially_running")]
6855    Partially_running,
6856    #[serde(rename = "provisioning")]
6857    Provisioning,
6858    #[serde(rename = "running")]
6859    Running,
6860    #[serde(rename = "stopped")]
6861    Stopped,
6862    #[serde(rename = "terminated")]
6863    Terminated,
6864    #[serde(rename = "softdeleted")]
6865    Softdeleted,
6866    #[serde(rename = "degraded")]
6867    Degraded,
6868    #[serde(rename = "failed")]
6869    Failed,
6870    #[serde(rename = "idle")]
6871    Idle,
6872    /// Catch-all for unknown or newly-added values.
6873    #[serde(untagged)]
6874    Unknown(String),
6875}
6876
6877impl std::fmt::Display for ServiceScalingPatchResponseState {
6878    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6879        match self {
6880            Self::Starting => write!(f, "starting"),
6881            Self::Stopping => write!(f, "stopping"),
6882            Self::Terminating => write!(f, "terminating"),
6883            Self::Softdeleting => write!(f, "softdeleting"),
6884            Self::Awaking => write!(f, "awaking"),
6885            Self::Partially_running => write!(f, "partially_running"),
6886            Self::Provisioning => write!(f, "provisioning"),
6887            Self::Running => write!(f, "running"),
6888            Self::Stopped => write!(f, "stopped"),
6889            Self::Terminated => write!(f, "terminated"),
6890            Self::Softdeleted => write!(f, "softdeleted"),
6891            Self::Degraded => write!(f, "degraded"),
6892            Self::Failed => write!(f, "failed"),
6893            Self::Idle => write!(f, "idle"),
6894            Self::Unknown(s) => write!(f, "{s}"),
6895        }
6896    }
6897}
6898
6899/// Inline enum for `ServiceScalingPatchResponse.tier`.
6900#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6901pub enum ServiceScalingPatchResponseTier {
6902    #[serde(rename = "development")]
6903    #[default]
6904    Development,
6905    #[serde(rename = "production")]
6906    Production,
6907    #[serde(rename = "dedicated_high_mem")]
6908    Dedicated_high_mem,
6909    #[serde(rename = "dedicated_high_cpu")]
6910    Dedicated_high_cpu,
6911    #[serde(rename = "dedicated_standard")]
6912    Dedicated_standard,
6913    #[serde(rename = "dedicated_standard_n2d_standard_4")]
6914    Dedicated_standard_n2d_standard_4,
6915    #[serde(rename = "dedicated_standard_n2d_standard_8")]
6916    Dedicated_standard_n2d_standard_8,
6917    #[serde(rename = "dedicated_standard_n2d_standard_32")]
6918    Dedicated_standard_n2d_standard_32,
6919    #[serde(rename = "dedicated_standard_n2d_standard_128")]
6920    Dedicated_standard_n2d_standard_128,
6921    #[serde(rename = "dedicated_standard_n2d_standard_32_16SSD")]
6922    Dedicated_standard_n2d_standard_32_16SSD,
6923    #[serde(rename = "dedicated_standard_n2d_standard_64_24SSD")]
6924    Dedicated_standard_n2d_standard_64_24SSD,
6925    /// Catch-all for unknown or newly-added values.
6926    #[serde(untagged)]
6927    Unknown(String),
6928}
6929
6930impl std::fmt::Display for ServiceScalingPatchResponseTier {
6931    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6932        match self {
6933            Self::Development => write!(f, "development"),
6934            Self::Production => write!(f, "production"),
6935            Self::Dedicated_high_mem => write!(f, "dedicated_high_mem"),
6936            Self::Dedicated_high_cpu => write!(f, "dedicated_high_cpu"),
6937            Self::Dedicated_standard => write!(f, "dedicated_standard"),
6938            Self::Dedicated_standard_n2d_standard_4 => write!(f, "dedicated_standard_n2d_standard_4"),
6939            Self::Dedicated_standard_n2d_standard_8 => write!(f, "dedicated_standard_n2d_standard_8"),
6940            Self::Dedicated_standard_n2d_standard_32 => write!(f, "dedicated_standard_n2d_standard_32"),
6941            Self::Dedicated_standard_n2d_standard_128 => write!(f, "dedicated_standard_n2d_standard_128"),
6942            Self::Dedicated_standard_n2d_standard_32_16SSD => write!(f, "dedicated_standard_n2d_standard_32_16SSD"),
6943            Self::Dedicated_standard_n2d_standard_64_24SSD => write!(f, "dedicated_standard_n2d_standard_64_24SSD"),
6944            Self::Unknown(s) => write!(f, "{s}"),
6945        }
6946    }
6947}
6948
6949/// Inline enum for `ServiceStatePatchRequest.command`.
6950#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6951pub enum ServiceStatePatchRequestCommand {
6952    #[serde(rename = "start")]
6953    #[default]
6954    Start,
6955    #[serde(rename = "stop")]
6956    Stop,
6957    #[serde(rename = "awake")]
6958    Awake,
6959    /// Catch-all for unknown or newly-added values.
6960    #[serde(untagged)]
6961    Unknown(String),
6962}
6963
6964impl std::fmt::Display for ServiceStatePatchRequestCommand {
6965    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6966        match self {
6967            Self::Start => write!(f, "start"),
6968            Self::Stop => write!(f, "stop"),
6969            Self::Awake => write!(f, "awake"),
6970            Self::Unknown(s) => write!(f, "{s}"),
6971        }
6972    }
6973}
6974
6975/// Inline enum for `UsageCostRecord.entityType`.
6976#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
6977pub enum UsageCostRecordEntitytype {
6978    #[serde(rename = "datawarehouse")]
6979    #[default]
6980    Datawarehouse,
6981    #[serde(rename = "service")]
6982    Service,
6983    #[serde(rename = "clickpipe")]
6984    Clickpipe,
6985    /// Catch-all for unknown or newly-added values.
6986    #[serde(untagged)]
6987    Unknown(String),
6988}
6989
6990impl std::fmt::Display for UsageCostRecordEntitytype {
6991    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
6992        match self {
6993            Self::Datawarehouse => write!(f, "datawarehouse"),
6994            Self::Service => write!(f, "service"),
6995            Self::Clickpipe => write!(f, "clickpipe"),
6996            Self::Unknown(s) => write!(f, "{s}"),
6997        }
6998    }
6999}
7000
7001/// Inline enum for `pgConfig.default_transaction_isolation`.
7002#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7003pub enum PgConfigDefaultTransactionIsolation {
7004    #[serde(rename = "read committed")]
7005    #[default]
7006    Read_committed,
7007    #[serde(rename = "repeatable read")]
7008    Repeatable_read,
7009    #[serde(rename = "serializable")]
7010    Serializable,
7011    /// Catch-all for unknown or newly-added values.
7012    #[serde(untagged)]
7013    Unknown(String),
7014}
7015
7016impl std::fmt::Display for PgConfigDefaultTransactionIsolation {
7017    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7018        match self {
7019            Self::Read_committed => write!(f, "read committed"),
7020            Self::Repeatable_read => write!(f, "repeatable read"),
7021            Self::Serializable => write!(f, "serializable"),
7022            Self::Unknown(s) => write!(f, "{s}"),
7023        }
7024    }
7025}
7026
7027/// Inline enum for `pgConfig.ssl_min_protocol_version`.
7028#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7029pub enum PgConfigSslMinProtocolVersion {
7030    #[serde(rename = "TLSv1")]
7031    #[default]
7032    TlsV1,
7033    #[serde(rename = "TLSv1.1")]
7034    TlsV1_1,
7035    #[serde(rename = "TLSv1.2")]
7036    TlsV1_2,
7037    #[serde(rename = "TLSv1.3")]
7038    TlsV1_3,
7039    /// Catch-all for unknown or newly-added values.
7040    #[serde(untagged)]
7041    Unknown(String),
7042}
7043
7044impl std::fmt::Display for PgConfigSslMinProtocolVersion {
7045    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7046        match self {
7047            Self::TlsV1 => write!(f, "TLSv1"),
7048            Self::TlsV1_1 => write!(f, "TLSv1.1"),
7049            Self::TlsV1_2 => write!(f, "TLSv1.2"),
7050            Self::TlsV1_3 => write!(f, "TLSv1.3"),
7051            Self::Unknown(s) => write!(f, "{s}"),
7052        }
7053    }
7054}
7055
7056/// Inline enum for `pgConfig.wal_compression`.
7057#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7058pub enum PgConfigWalCompression {
7059    #[serde(rename = "off")]
7060    #[default]
7061    Off,
7062    #[serde(rename = "on")]
7063    On,
7064    #[serde(rename = "lz4")]
7065    Lz4,
7066    #[serde(rename = "zstd")]
7067    Zstd,
7068    /// Catch-all for unknown or newly-added values.
7069    #[serde(untagged)]
7070    Unknown(String),
7071}
7072
7073impl std::fmt::Display for PgConfigWalCompression {
7074    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7075        match self {
7076            Self::Off => write!(f, "off"),
7077            Self::On => write!(f, "on"),
7078            Self::Lz4 => write!(f, "lz4"),
7079            Self::Zstd => write!(f, "zstd"),
7080            Self::Unknown(s) => write!(f, "{s}"),
7081        }
7082    }
7083}
7084
7085/// `BackupBucket` - one of multiple variants.
7086///
7087/// Uses `bucketProvider` as a discriminator: `"AWS"`, `"GCP"`, or `"AZURE"`.
7088#[derive(Debug, Clone, PartialEq, Serialize)]
7089#[serde(untagged)]
7090pub enum BackupBucket {
7091    AwsBackupBucket(AwsBackupBucket),
7092    GcpBackupBucket(GcpBackupBucket),
7093    AzureBackupBucket(AzureBackupBucket),
7094    /// Catch-all for unknown or newly-added values.
7095    Unknown(String),
7096}
7097
7098impl<'de> Deserialize<'de> for BackupBucket {
7099    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7100    where
7101        D: serde::Deserializer<'de>,
7102    {
7103        let value = serde_json::Value::deserialize(deserializer)?;
7104        match value.get("bucketProvider").and_then(|v| v.as_str()) {
7105            Some("AWS") => serde_json::from_value(value)
7106                .map(BackupBucket::AwsBackupBucket)
7107                .map_err(serde::de::Error::custom),
7108            Some("GCP") => serde_json::from_value(value)
7109                .map(BackupBucket::GcpBackupBucket)
7110                .map_err(serde::de::Error::custom),
7111            Some("AZURE") => serde_json::from_value(value)
7112                .map(BackupBucket::AzureBackupBucket)
7113                .map_err(serde::de::Error::custom),
7114            _ => Ok(BackupBucket::Unknown(value.to_string())),
7115        }
7116    }
7117}
7118
7119impl std::fmt::Display for BackupBucket {
7120    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7121        match self {
7122            Self::AwsBackupBucket(_) => write!(f, "AwsBackupBucket"),
7123            Self::GcpBackupBucket(_) => write!(f, "GcpBackupBucket"),
7124            Self::AzureBackupBucket(_) => write!(f, "AzureBackupBucket"),
7125            Self::Unknown(s) => write!(f, "{s}"),
7126        }
7127    }
7128}
7129
7130/// `BackupBucketPatchRequest` - one of multiple variants.
7131///
7132/// Uses `bucketProvider` as a discriminator: `"AWS"`, `"GCP"`, or `"AZURE"`.
7133#[derive(Debug, Clone, PartialEq, Serialize)]
7134#[serde(untagged)]
7135pub enum BackupBucketPatchRequest {
7136    AwsBackupBucketPatchRequestV1(AwsBackupBucketPatchRequestV1),
7137    GcpBackupBucketPatchRequestV1(GcpBackupBucketPatchRequestV1),
7138    AzureBackupBucketPatchRequestV1(AzureBackupBucketPatchRequestV1),
7139    /// Catch-all for unknown or newly-added values.
7140    Unknown(String),
7141}
7142
7143impl<'de> Deserialize<'de> for BackupBucketPatchRequest {
7144    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7145    where
7146        D: serde::Deserializer<'de>,
7147    {
7148        let value = serde_json::Value::deserialize(deserializer)?;
7149        match value.get("bucketProvider").and_then(|v| v.as_str()) {
7150            Some("AWS") => serde_json::from_value(value)
7151                .map(BackupBucketPatchRequest::AwsBackupBucketPatchRequestV1)
7152                .map_err(serde::de::Error::custom),
7153            Some("GCP") => serde_json::from_value(value)
7154                .map(BackupBucketPatchRequest::GcpBackupBucketPatchRequestV1)
7155                .map_err(serde::de::Error::custom),
7156            Some("AZURE") => serde_json::from_value(value)
7157                .map(BackupBucketPatchRequest::AzureBackupBucketPatchRequestV1)
7158                .map_err(serde::de::Error::custom),
7159            _ => Ok(BackupBucketPatchRequest::Unknown(value.to_string())),
7160        }
7161    }
7162}
7163
7164impl std::fmt::Display for BackupBucketPatchRequest {
7165    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7166        match self {
7167            Self::AwsBackupBucketPatchRequestV1(_) => write!(f, "AwsBackupBucketPatchRequestV1"),
7168            Self::GcpBackupBucketPatchRequestV1(_) => write!(f, "GcpBackupBucketPatchRequestV1"),
7169            Self::AzureBackupBucketPatchRequestV1(_) => write!(f, "AzureBackupBucketPatchRequestV1"),
7170            Self::Unknown(s) => write!(f, "{s}"),
7171        }
7172    }
7173}
7174
7175/// `BackupBucketPostRequest` - one of multiple variants.
7176///
7177/// Uses `bucketProvider` as a discriminator: `"AWS"`, `"GCP"`, or `"AZURE"`.
7178#[derive(Debug, Clone, PartialEq, Serialize)]
7179#[serde(untagged)]
7180pub enum BackupBucketPostRequest {
7181    AwsBackupBucketPostRequestV1(AwsBackupBucketPostRequestV1),
7182    GcpBackupBucketPostRequestV1(GcpBackupBucketPostRequestV1),
7183    AzureBackupBucketPostRequestV1(AzureBackupBucketPostRequestV1),
7184    /// Catch-all for unknown or newly-added values.
7185    Unknown(String),
7186}
7187
7188impl<'de> Deserialize<'de> for BackupBucketPostRequest {
7189    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7190    where
7191        D: serde::Deserializer<'de>,
7192    {
7193        let value = serde_json::Value::deserialize(deserializer)?;
7194        match value.get("bucketProvider").and_then(|v| v.as_str()) {
7195            Some("AWS") => serde_json::from_value(value)
7196                .map(BackupBucketPostRequest::AwsBackupBucketPostRequestV1)
7197                .map_err(serde::de::Error::custom),
7198            Some("GCP") => serde_json::from_value(value)
7199                .map(BackupBucketPostRequest::GcpBackupBucketPostRequestV1)
7200                .map_err(serde::de::Error::custom),
7201            Some("AZURE") => serde_json::from_value(value)
7202                .map(BackupBucketPostRequest::AzureBackupBucketPostRequestV1)
7203                .map_err(serde::de::Error::custom),
7204            _ => Ok(BackupBucketPostRequest::Unknown(value.to_string())),
7205        }
7206    }
7207}
7208
7209impl std::fmt::Display for BackupBucketPostRequest {
7210    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7211        match self {
7212            Self::AwsBackupBucketPostRequestV1(_) => write!(f, "AwsBackupBucketPostRequestV1"),
7213            Self::GcpBackupBucketPostRequestV1(_) => write!(f, "GcpBackupBucketPostRequestV1"),
7214            Self::AzureBackupBucketPostRequestV1(_) => write!(f, "AzureBackupBucketPostRequestV1"),
7215            Self::Unknown(s) => write!(f, "{s}"),
7216        }
7217    }
7218}
7219
7220/// `BackupBucketProperties` - one of multiple variants.
7221///
7222/// Uses `bucketProvider` as a discriminator: `"AWS"`, `"GCP"`, or `"AZURE"`.
7223#[derive(Debug, Clone, PartialEq, Serialize)]
7224#[serde(untagged)]
7225pub enum BackupBucketProperties {
7226    AwsBackupBucketProperties(AwsBackupBucketProperties),
7227    GcpBackupBucketProperties(GcpBackupBucketProperties),
7228    AzureBackupBucketProperties(AzureBackupBucketProperties),
7229    /// Catch-all for unknown or newly-added values.
7230    Unknown(String),
7231}
7232
7233impl<'de> Deserialize<'de> for BackupBucketProperties {
7234    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
7235    where
7236        D: serde::Deserializer<'de>,
7237    {
7238        let value = serde_json::Value::deserialize(deserializer)?;
7239        match value.get("bucketProvider").and_then(|v| v.as_str()) {
7240            Some("AWS") => serde_json::from_value(value)
7241                .map(BackupBucketProperties::AwsBackupBucketProperties)
7242                .map_err(serde::de::Error::custom),
7243            Some("GCP") => serde_json::from_value(value)
7244                .map(BackupBucketProperties::GcpBackupBucketProperties)
7245                .map_err(serde::de::Error::custom),
7246            Some("AZURE") => serde_json::from_value(value)
7247                .map(BackupBucketProperties::AzureBackupBucketProperties)
7248                .map_err(serde::de::Error::custom),
7249            _ => Ok(BackupBucketProperties::Unknown(value.to_string())),
7250        }
7251    }
7252}
7253
7254impl std::fmt::Display for BackupBucketProperties {
7255    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7256        match self {
7257            Self::AwsBackupBucketProperties(_) => write!(f, "AwsBackupBucketProperties"),
7258            Self::GcpBackupBucketProperties(_) => write!(f, "GcpBackupBucketProperties"),
7259            Self::AzureBackupBucketProperties(_) => write!(f, "AzureBackupBucketProperties"),
7260            Self::Unknown(s) => write!(f, "{s}"),
7261        }
7262    }
7263}
7264
7265/// `ClickStackAlertChannel` - one of multiple variants.
7266#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7267#[serde(untagged)]
7268pub enum ClickStackAlertChannel {
7269    ClickStackAlertChannelEmail(ClickStackAlertChannelEmail),
7270    ClickStackAlertChannelWebhook(ClickStackAlertChannelWebhook),
7271    /// Catch-all for unknown or newly-added values.
7272    Unknown(String),
7273}
7274
7275impl std::fmt::Display for ClickStackAlertChannel {
7276    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7277        match self {
7278            Self::ClickStackAlertChannelEmail(_) => write!(f, "ClickStackAlertChannelEmail"),
7279            Self::ClickStackAlertChannelWebhook(_) => write!(f, "ClickStackAlertChannelWebhook"),
7280            Self::Unknown(s) => write!(f, "{s}"),
7281        }
7282    }
7283}
7284
7285/// `ClickStackBarChartConfig` - one of multiple variants.
7286#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7287#[serde(untagged)]
7288pub enum ClickStackBarChartConfig {
7289    ClickStackBarBuilderChartConfig(ClickStackBarBuilderChartConfig),
7290    ClickStackBarRawSqlChartConfig(ClickStackBarRawSqlChartConfig),
7291    /// Catch-all for unknown or newly-added values.
7292    Unknown(String),
7293}
7294
7295impl std::fmt::Display for ClickStackBarChartConfig {
7296    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7297        match self {
7298            Self::ClickStackBarBuilderChartConfig(_) => write!(f, "ClickStackBarBuilderChartConfig"),
7299            Self::ClickStackBarRawSqlChartConfig(_) => write!(f, "ClickStackBarRawSqlChartConfig"),
7300            Self::Unknown(s) => write!(f, "{s}"),
7301        }
7302    }
7303}
7304
7305/// `ClickStackDashboardChartSeries` - one of multiple variants.
7306#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7307#[serde(untagged)]
7308pub enum ClickStackDashboardChartSeries {
7309    ClickStackTimeChartSeries(ClickStackTimeChartSeries),
7310    ClickStackTableChartSeries(ClickStackTableChartSeries),
7311    ClickStackNumberChartSeries(ClickStackNumberChartSeries),
7312    ClickStackSearchChartSeries(ClickStackSearchChartSeries),
7313    ClickStackMarkdownChartSeries(ClickStackMarkdownChartSeries),
7314    /// Catch-all for unknown or newly-added values.
7315    Unknown(String),
7316}
7317
7318impl std::fmt::Display for ClickStackDashboardChartSeries {
7319    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7320        match self {
7321            Self::ClickStackTimeChartSeries(_) => write!(f, "ClickStackTimeChartSeries"),
7322            Self::ClickStackTableChartSeries(_) => write!(f, "ClickStackTableChartSeries"),
7323            Self::ClickStackNumberChartSeries(_) => write!(f, "ClickStackNumberChartSeries"),
7324            Self::ClickStackSearchChartSeries(_) => write!(f, "ClickStackSearchChartSeries"),
7325            Self::ClickStackMarkdownChartSeries(_) => write!(f, "ClickStackMarkdownChartSeries"),
7326            Self::Unknown(s) => write!(f, "{s}"),
7327        }
7328    }
7329}
7330
7331/// `ClickStackLineChartConfig` - one of multiple variants.
7332#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7333#[serde(untagged)]
7334pub enum ClickStackLineChartConfig {
7335    ClickStackLineBuilderChartConfig(ClickStackLineBuilderChartConfig),
7336    ClickStackLineRawSqlChartConfig(ClickStackLineRawSqlChartConfig),
7337    /// Catch-all for unknown or newly-added values.
7338    Unknown(String),
7339}
7340
7341impl std::fmt::Display for ClickStackLineChartConfig {
7342    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7343        match self {
7344            Self::ClickStackLineBuilderChartConfig(_) => write!(f, "ClickStackLineBuilderChartConfig"),
7345            Self::ClickStackLineRawSqlChartConfig(_) => write!(f, "ClickStackLineRawSqlChartConfig"),
7346            Self::Unknown(s) => write!(f, "{s}"),
7347        }
7348    }
7349}
7350
7351/// `ClickStackNumberChartConfig` - one of multiple variants.
7352#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7353#[serde(untagged)]
7354pub enum ClickStackNumberChartConfig {
7355    ClickStackNumberBuilderChartConfig(ClickStackNumberBuilderChartConfig),
7356    ClickStackNumberRawSqlChartConfig(ClickStackNumberRawSqlChartConfig),
7357    /// Catch-all for unknown or newly-added values.
7358    Unknown(String),
7359}
7360
7361impl std::fmt::Display for ClickStackNumberChartConfig {
7362    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7363        match self {
7364            Self::ClickStackNumberBuilderChartConfig(_) => write!(f, "ClickStackNumberBuilderChartConfig"),
7365            Self::ClickStackNumberRawSqlChartConfig(_) => write!(f, "ClickStackNumberRawSqlChartConfig"),
7366            Self::Unknown(s) => write!(f, "{s}"),
7367        }
7368    }
7369}
7370
7371/// `ClickStackOnClick` - one of multiple variants.
7372#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7373#[serde(untagged)]
7374pub enum ClickStackOnClick {
7375    ClickStackOnClickSearch(ClickStackOnClickSearch),
7376    ClickStackOnClickDashboard(ClickStackOnClickDashboard),
7377    /// Catch-all for unknown or newly-added values.
7378    Unknown(String),
7379}
7380
7381impl Default for ClickStackOnClick {
7382    fn default() -> Self {
7383        Self::Unknown(String::new())
7384    }
7385}
7386
7387impl std::fmt::Display for ClickStackOnClick {
7388    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7389        match self {
7390            Self::ClickStackOnClickSearch(_) => write!(f, "ClickStackOnClickSearch"),
7391            Self::ClickStackOnClickDashboard(_) => write!(f, "ClickStackOnClickDashboard"),
7392            Self::Unknown(s) => write!(f, "{s}"),
7393        }
7394    }
7395}
7396
7397/// `ClickStackOnClickTarget` - one of multiple variants.
7398#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7399#[serde(untagged)]
7400pub enum ClickStackOnClickTarget {
7401    ClickStackOnClickTargetIdVariant(ClickStackOnClickTargetIdVariant),
7402    ClickStackOnClickTargetTemplateVariant(ClickStackOnClickTargetTemplateVariant),
7403    /// Catch-all for unknown or newly-added values.
7404    Unknown(String),
7405}
7406
7407impl Default for ClickStackOnClickTarget {
7408    fn default() -> Self {
7409        Self::Unknown(String::new())
7410    }
7411}
7412
7413impl std::fmt::Display for ClickStackOnClickTarget {
7414    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7415        match self {
7416            Self::ClickStackOnClickTargetIdVariant(_) => write!(f, "ClickStackOnClickTargetIdVariant"),
7417            Self::ClickStackOnClickTargetTemplateVariant(_) => write!(f, "ClickStackOnClickTargetTemplateVariant"),
7418            Self::Unknown(s) => write!(f, "{s}"),
7419        }
7420    }
7421}
7422
7423/// `ClickStackPieChartConfig` - one of multiple variants.
7424#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7425#[serde(untagged)]
7426pub enum ClickStackPieChartConfig {
7427    ClickStackPieBuilderChartConfig(ClickStackPieBuilderChartConfig),
7428    ClickStackPieRawSqlChartConfig(ClickStackPieRawSqlChartConfig),
7429    /// Catch-all for unknown or newly-added values.
7430    Unknown(String),
7431}
7432
7433impl std::fmt::Display for ClickStackPieChartConfig {
7434    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7435        match self {
7436            Self::ClickStackPieBuilderChartConfig(_) => write!(f, "ClickStackPieBuilderChartConfig"),
7437            Self::ClickStackPieRawSqlChartConfig(_) => write!(f, "ClickStackPieRawSqlChartConfig"),
7438            Self::Unknown(s) => write!(f, "{s}"),
7439        }
7440    }
7441}
7442
7443/// `ClickStackSource` - one of multiple variants.
7444#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7445#[serde(untagged)]
7446pub enum ClickStackSource {
7447    ClickStackLogSource(ClickStackLogSource),
7448    ClickStackTraceSource(ClickStackTraceSource),
7449    ClickStackMetricSource(ClickStackMetricSource),
7450    ClickStackSessionSource(ClickStackSessionSource),
7451    /// Catch-all for unknown or newly-added values.
7452    Unknown(String),
7453}
7454
7455impl std::fmt::Display for ClickStackSource {
7456    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7457        match self {
7458            Self::ClickStackLogSource(_) => write!(f, "ClickStackLogSource"),
7459            Self::ClickStackTraceSource(_) => write!(f, "ClickStackTraceSource"),
7460            Self::ClickStackMetricSource(_) => write!(f, "ClickStackMetricSource"),
7461            Self::ClickStackSessionSource(_) => write!(f, "ClickStackSessionSource"),
7462            Self::Unknown(s) => write!(f, "{s}"),
7463        }
7464    }
7465}
7466
7467/// `ClickStackTableChartConfig` - one of multiple variants.
7468#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7469#[serde(untagged)]
7470pub enum ClickStackTableChartConfig {
7471    ClickStackTableBuilderChartConfig(ClickStackTableBuilderChartConfig),
7472    ClickStackTableRawSqlChartConfig(ClickStackTableRawSqlChartConfig),
7473    /// Catch-all for unknown or newly-added values.
7474    Unknown(String),
7475}
7476
7477impl std::fmt::Display for ClickStackTableChartConfig {
7478    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7479        match self {
7480            Self::ClickStackTableBuilderChartConfig(_) => write!(f, "ClickStackTableBuilderChartConfig"),
7481            Self::ClickStackTableRawSqlChartConfig(_) => write!(f, "ClickStackTableRawSqlChartConfig"),
7482            Self::Unknown(s) => write!(f, "{s}"),
7483        }
7484    }
7485}
7486
7487/// `ClickStackTileConfig` - one of multiple variants.
7488#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7489#[serde(untagged)]
7490pub enum ClickStackTileConfig {
7491    ClickStackLineChartConfig(ClickStackLineChartConfig),
7492    ClickStackBarChartConfig(ClickStackBarChartConfig),
7493    ClickStackTableChartConfig(ClickStackTableChartConfig),
7494    ClickStackNumberChartConfig(ClickStackNumberChartConfig),
7495    ClickStackPieChartConfig(ClickStackPieChartConfig),
7496    ClickStackHeatmapChartConfig(ClickStackHeatmapChartConfig),
7497    ClickStackSearchChartConfig(ClickStackSearchChartConfig),
7498    ClickStackMarkdownChartConfig(ClickStackMarkdownChartConfig),
7499    /// Catch-all for unknown or newly-added values.
7500    Unknown(String),
7501}
7502
7503impl std::fmt::Display for ClickStackTileConfig {
7504    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7505        match self {
7506            Self::ClickStackLineChartConfig(_) => write!(f, "ClickStackLineChartConfig"),
7507            Self::ClickStackBarChartConfig(_) => write!(f, "ClickStackBarChartConfig"),
7508            Self::ClickStackTableChartConfig(_) => write!(f, "ClickStackTableChartConfig"),
7509            Self::ClickStackNumberChartConfig(_) => write!(f, "ClickStackNumberChartConfig"),
7510            Self::ClickStackPieChartConfig(_) => write!(f, "ClickStackPieChartConfig"),
7511            Self::ClickStackHeatmapChartConfig(_) => write!(f, "ClickStackHeatmapChartConfig"),
7512            Self::ClickStackSearchChartConfig(_) => write!(f, "ClickStackSearchChartConfig"),
7513            Self::ClickStackMarkdownChartConfig(_) => write!(f, "ClickStackMarkdownChartConfig"),
7514            Self::Unknown(s) => write!(f, "{s}"),
7515        }
7516    }
7517}
7518
7519/// `ClickStackWebhook` - one of multiple variants.
7520#[derive(Debug, Clone, PartialEq, Serialize, Deserialize)]
7521#[serde(untagged)]
7522pub enum ClickStackWebhook {
7523    ClickStackSlackWebhook(ClickStackSlackWebhook),
7524    ClickStackIncidentIOWebhook(ClickStackIncidentIOWebhook),
7525    ClickStackGenericWebhook(ClickStackGenericWebhook),
7526    ClickStackSlackAPIWebhook(ClickStackSlackAPIWebhook),
7527    ClickStackPagerDutyAPIWebhook(ClickStackPagerDutyAPIWebhook),
7528    /// Catch-all for unknown or newly-added values.
7529    Unknown(String),
7530}
7531
7532impl std::fmt::Display for ClickStackWebhook {
7533    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
7534        match self {
7535            Self::ClickStackSlackWebhook(_) => write!(f, "ClickStackSlackWebhook"),
7536            Self::ClickStackIncidentIOWebhook(_) => write!(f, "ClickStackIncidentIOWebhook"),
7537            Self::ClickStackGenericWebhook(_) => write!(f, "ClickStackGenericWebhook"),
7538            Self::ClickStackSlackAPIWebhook(_) => write!(f, "ClickStackSlackAPIWebhook"),
7539            Self::ClickStackPagerDutyAPIWebhook(_) => write!(f, "ClickStackPagerDutyAPIWebhook"),
7540            Self::Unknown(s) => write!(f, "{s}"),
7541        }
7542    }
7543}
7544
7545/// Type alias for `pgCreatedAtProperty`.
7546pub type PgCreatedAtProperty = chrono::DateTime<chrono::Utc>;
7547
7548/// Type alias for `pgIdProperty`.
7549pub type PgIdProperty = uuid::Uuid;
7550
7551/// Type alias for `pgIsPrimaryProperty`.
7552pub type PgIsPrimaryProperty = bool;
7553
7554/// Type alias for `pgNameProperty`.
7555pub type PgNameProperty = String;
7556
7557/// Type alias for `pgPassword`.
7558pub type PgPassword = String;
7559
7560/// Type alias for `pgPitrRestoreTargetProperty`.
7561pub type PgPitrRestoreTargetProperty = chrono::DateTime<chrono::Utc>;
7562
7563/// Type alias for `pgRegion`.
7564pub type PgRegion = String;
7565
7566/// Type alias for `pgStorageSize`.
7567pub type PgStorageSize = i64;
7568
7569/// Type alias for `pgTags`.
7570pub type PgTags = Vec<ResourceTagsV1>;
7571
7572/// `Activity` from the ClickHouse Cloud API.
7573#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7574pub struct Activity {
7575    #[serde(rename = "actorDetails", default)]
7576    pub actor_details: String,
7577    #[serde(rename = "actorId", default)]
7578    pub actor_id: String,
7579    #[serde(rename = "actorIpAddress", default)]
7580    pub actor_ip_address: String,
7581    #[serde(rename = "actorType", default)]
7582    pub actor_type: ActivityActortype,
7583    #[serde(rename = "createdAt", default)]
7584    pub created_at: chrono::DateTime<chrono::Utc>,
7585    #[serde(default)]
7586    pub id: String,
7587    #[serde(rename = "keyUpdateType", default)]
7588    pub key_update_type: ActivityKeyupdatetype,
7589    #[serde(rename = "organizationId", default)]
7590    pub organization_id: String,
7591    #[serde(rename = "serviceId", default)]
7592    pub service_id: String,
7593    #[serde(rename = "targetKeyId", default)]
7594    pub target_key_id: String,
7595    #[serde(default)]
7596    pub r#type: ActivityType,
7597    #[serde(rename = "userAgent", default)]
7598    pub user_agent: String,
7599}
7600
7601/// `ApiKey` from the ClickHouse Cloud API.
7602#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7603pub struct ApiKey {
7604    #[serde(rename = "assignedRoles", default)]
7605    pub assigned_roles: Vec<AssignedRole>,
7606    #[serde(rename = "createdAt", default)]
7607    pub created_at: chrono::DateTime<chrono::Utc>,
7608    #[serde(rename = "expireAt", skip_serializing_if = "Option::is_none", default)]
7609    pub expire_at: Option<chrono::DateTime<chrono::Utc>>,
7610    #[serde(default)]
7611    pub id: uuid::Uuid,
7612    #[serde(rename = "ipAccessList", default)]
7613    pub ip_access_list: Vec<IpAccessListEntry>,
7614    #[serde(rename = "keySuffix", default)]
7615    pub key_suffix: String,
7616    #[serde(default)]
7617    pub name: String,
7618    #[cfg(feature = "deprecated-fields")]
7619    #[serde(default)]
7620    pub roles: Vec<String>,
7621    #[serde(default)]
7622    pub state: ApiKeyState,
7623    #[serde(rename = "usedAt", default)]
7624    pub used_at: chrono::DateTime<chrono::Utc>,
7625}
7626
7627/// `ApiKeyHashData` from the ClickHouse Cloud API.
7628#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7629pub struct ApiKeyHashData {
7630    #[serde(rename = "keyIdHash", default)]
7631    pub key_id_hash: String,
7632    #[serde(rename = "keyIdSuffix", default)]
7633    pub key_id_suffix: String,
7634    #[serde(rename = "keySecretHash", default)]
7635    pub key_secret_hash: String,
7636}
7637
7638/// `ApiKeyPatchRequest` from the ClickHouse Cloud API.
7639#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7640pub struct ApiKeyPatchRequest {
7641    #[serde(rename = "assignedRoleIds", skip_serializing_if = "Option::is_none", default)]
7642    pub assigned_role_ids: Option<Vec<uuid::Uuid>>,
7643    #[serde(rename = "expireAt", skip_serializing_if = "Option::is_none", default)]
7644    pub expire_at: Option<chrono::DateTime<chrono::Utc>>,
7645    #[serde(rename = "ipAccessList", skip_serializing_if = "Option::is_none", default)]
7646    pub ip_access_list: Option<Vec<IpAccessListEntry>>,
7647    #[serde(skip_serializing_if = "Option::is_none", default)]
7648    pub name: Option<String>,
7649    #[cfg(feature = "deprecated-fields")]
7650    #[serde(skip_serializing_if = "Option::is_none", default)]
7651    pub roles: Option<Vec<String>>,
7652    #[serde(skip_serializing_if = "Option::is_none", default)]
7653    pub state: Option<ApiKeyPatchRequestState>,
7654}
7655
7656/// `ApiKeyPostRequest` from the ClickHouse Cloud API.
7657#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7658pub struct ApiKeyPostRequest {
7659    #[serde(rename = "assignedRoleIds", default)]
7660    pub assigned_role_ids: Vec<uuid::Uuid>,
7661    #[serde(rename = "expireAt", skip_serializing_if = "Option::is_none", default)]
7662    pub expire_at: Option<chrono::DateTime<chrono::Utc>>,
7663    #[serde(rename = "hashData", skip_serializing_if = "Option::is_none", default)]
7664    pub hash_data: Option<ApiKeyHashData>,
7665    #[serde(rename = "ipAccessList", default)]
7666    pub ip_access_list: Vec<IpAccessListEntry>,
7667    #[serde(default)]
7668    pub name: String,
7669    #[cfg(feature = "deprecated-fields")]
7670    #[serde(skip_serializing_if = "Option::is_none", default)]
7671    pub roles: Option<Vec<String>>,
7672    #[serde(default)]
7673    pub state: ApiKeyPostRequestState,
7674}
7675
7676/// `ApiKeyPostResponse` from the ClickHouse Cloud API.
7677#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7678pub struct ApiKeyPostResponse {
7679    #[serde(default)]
7680    pub key: ApiKey,
7681    #[serde(rename = "keyId", default)]
7682    pub key_id: String,
7683    #[serde(rename = "keySecret", default)]
7684    pub key_secret: String,
7685}
7686
7687/// `AssignedRole` from the ClickHouse Cloud API.
7688#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7689pub struct AssignedRole {
7690    #[serde(rename = "roleId", default)]
7691    pub role_id: uuid::Uuid,
7692    #[serde(rename = "roleName", default)]
7693    pub role_name: String,
7694    #[serde(rename = "roleType", default)]
7695    pub role_type: AssignedRoleRoletype,
7696}
7697
7698/// `AwsBackupBucket` from the ClickHouse Cloud API.
7699#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7700pub struct AwsBackupBucket {
7701    #[serde(rename = "bucketPath", default)]
7702    pub bucket_path: String,
7703    #[serde(rename = "bucketProvider", default)]
7704    pub bucket_provider: AwsBackupBucketBucketprovider,
7705    #[serde(rename = "iamRoleArn", default)]
7706    pub iam_role_arn: String,
7707    #[serde(rename = "iamRoleSessionName", default)]
7708    pub iam_role_session_name: String,
7709    #[serde(default)]
7710    pub id: uuid::Uuid,
7711}
7712
7713/// `AwsBackupBucketPatchRequestV1` from the ClickHouse Cloud API.
7714#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7715pub struct AwsBackupBucketPatchRequestV1 {
7716    #[serde(rename = "bucketPath", default)]
7717    pub bucket_path: String,
7718    #[serde(rename = "bucketProvider", default)]
7719    pub bucket_provider: AwsBackupBucketPatchRequestV1Bucketprovider,
7720    #[serde(rename = "iamRoleArn", default)]
7721    pub iam_role_arn: String,
7722    #[serde(rename = "iamRoleSessionName", skip_serializing_if = "Option::is_none", default)]
7723    pub iam_role_session_name: Option<String>,
7724}
7725
7726/// `AwsBackupBucketPostRequestV1` from the ClickHouse Cloud API.
7727#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7728pub struct AwsBackupBucketPostRequestV1 {
7729    #[serde(rename = "bucketPath", default)]
7730    pub bucket_path: String,
7731    #[serde(rename = "bucketProvider", default)]
7732    pub bucket_provider: AwsBackupBucketPostRequestV1Bucketprovider,
7733    #[serde(rename = "iamRoleArn", default)]
7734    pub iam_role_arn: String,
7735    #[serde(rename = "iamRoleSessionName", default)]
7736    pub iam_role_session_name: String,
7737}
7738
7739/// `AwsBackupBucketProperties` from the ClickHouse Cloud API.
7740#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7741pub struct AwsBackupBucketProperties {
7742    #[serde(rename = "bucketPath", default)]
7743    pub bucket_path: String,
7744    #[serde(rename = "bucketProvider", default)]
7745    pub bucket_provider: AwsBackupBucketPropertiesBucketprovider,
7746    #[serde(rename = "iamRoleArn", default)]
7747    pub iam_role_arn: String,
7748    #[serde(rename = "iamRoleSessionName", default)]
7749    pub iam_role_session_name: String,
7750}
7751
7752/// `AzureBackupBucket` from the ClickHouse Cloud API.
7753#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7754pub struct AzureBackupBucket {
7755    #[serde(rename = "bucketProvider", default)]
7756    pub bucket_provider: AzureBackupBucketBucketprovider,
7757    #[serde(rename = "containerName", default)]
7758    pub container_name: String,
7759    #[serde(default)]
7760    pub id: uuid::Uuid,
7761}
7762
7763/// `AzureBackupBucketPatchRequestV1` from the ClickHouse Cloud API.
7764#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7765pub struct AzureBackupBucketPatchRequestV1 {
7766    #[serde(rename = "bucketProvider", default)]
7767    pub bucket_provider: AzureBackupBucketPatchRequestV1Bucketprovider,
7768    #[serde(rename = "connectionString", default)]
7769    pub connection_string: String,
7770    #[serde(rename = "containerName", default)]
7771    pub container_name: String,
7772}
7773
7774/// `AzureBackupBucketPostRequestV1` from the ClickHouse Cloud API.
7775#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7776pub struct AzureBackupBucketPostRequestV1 {
7777    #[serde(rename = "bucketProvider", default)]
7778    pub bucket_provider: AzureBackupBucketPostRequestV1Bucketprovider,
7779    #[serde(rename = "connectionString", default)]
7780    pub connection_string: String,
7781    #[serde(rename = "containerName", default)]
7782    pub container_name: String,
7783}
7784
7785/// `AzureBackupBucketProperties` from the ClickHouse Cloud API.
7786#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7787pub struct AzureBackupBucketProperties {
7788    #[serde(rename = "bucketProvider", default)]
7789    pub bucket_provider: AzureBackupBucketPropertiesBucketprovider,
7790    #[serde(rename = "containerName", default)]
7791    pub container_name: String,
7792}
7793
7794/// `AzureEventHub` from the ClickHouse Cloud API.
7795#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7796pub struct AzureEventHub {
7797    #[serde(rename = "connectionString", default)]
7798    pub connection_string: String,
7799}
7800
7801/// `Backup` from the ClickHouse Cloud API.
7802#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7803pub struct Backup {
7804    #[serde(rename = "backupName", default)]
7805    pub backup_name: String,
7806    #[serde(default)]
7807    pub bucket: serde_json::Value,
7808    #[serde(rename = "durationInSeconds", default)]
7809    pub duration_in_seconds: f64,
7810    #[serde(rename = "finishedAt", default)]
7811    pub finished_at: chrono::DateTime<chrono::Utc>,
7812    #[serde(default)]
7813    pub id: uuid::Uuid,
7814    #[serde(rename = "serviceId", default)]
7815    pub service_id: String,
7816    #[serde(rename = "sizeInBytes", default)]
7817    pub size_in_bytes: f64,
7818    #[serde(rename = "startedAt", default)]
7819    pub started_at: chrono::DateTime<chrono::Utc>,
7820    #[serde(default)]
7821    pub status: BackupStatus,
7822    #[serde(default)]
7823    pub r#type: BackupType,
7824}
7825
7826/// `BackupConfiguration` from the ClickHouse Cloud API.
7827#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7828pub struct BackupConfiguration {
7829    #[serde(rename = "backupPeriodInHours", default)]
7830    pub backup_period_in_hours: f64,
7831    #[serde(rename = "backupRetentionPeriodInHours", default)]
7832    pub backup_retention_period_in_hours: f64,
7833    #[serde(rename = "backupStartTime", default)]
7834    pub backup_start_time: String,
7835}
7836
7837/// `BackupConfigurationPatchRequest` from the ClickHouse Cloud API.
7838#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7839pub struct BackupConfigurationPatchRequest {
7840    #[serde(rename = "backupPeriodInHours", skip_serializing_if = "Option::is_none", default)]
7841    pub backup_period_in_hours: Option<f64>,
7842    #[serde(rename = "backupRetentionPeriodInHours", skip_serializing_if = "Option::is_none", default)]
7843    pub backup_retention_period_in_hours: Option<f64>,
7844    #[serde(rename = "backupStartTime", skip_serializing_if = "Option::is_none", default)]
7845    pub backup_start_time: Option<String>,
7846}
7847
7848/// `BasePostgresService` from the ClickHouse Cloud API.
7849#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7850pub struct BasePostgresService {
7851    #[serde(rename = "haType", default)]
7852    pub ha_type: PgHaType,
7853    #[serde(default)]
7854    pub name: PgNameProperty,
7855    #[serde(rename = "postgresVersion", default)]
7856    pub postgres_version: PgVersion,
7857    #[serde(default)]
7858    pub provider: PgProvider,
7859    #[serde(default)]
7860    pub region: PgRegion,
7861    #[serde(default)]
7862    pub size: PgSize,
7863    #[serde(default)]
7864    pub tags: PgTags,
7865}
7866
7867/// `ByocConfig` from the ClickHouse Cloud API.
7868#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7869pub struct ByocConfig {
7870    #[serde(rename = "accountName", default)]
7871    pub account_name: String,
7872    #[serde(rename = "cloudProvider", default)]
7873    pub cloud_provider: ByocConfigCloudprovider,
7874    #[serde(rename = "displayName", default)]
7875    pub display_name: String,
7876    #[serde(default)]
7877    pub id: String,
7878    #[serde(rename = "regionId", default)]
7879    pub region_id: ByocConfigRegionid,
7880    #[serde(default)]
7881    pub state: ByocConfigState,
7882}
7883
7884/// `ByocInfrastructurePatchRequest` from the ClickHouse Cloud API.
7885#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7886pub struct ByocInfrastructurePatchRequest {
7887    #[serde(rename = "displayName", skip_serializing_if = "Option::is_none", default)]
7888    pub display_name: Option<String>,
7889}
7890
7891/// `ByocInfrastructurePostRequest` from the ClickHouse Cloud API.
7892#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7893pub struct ByocInfrastructurePostRequest {
7894    #[serde(rename = "accountId", default)]
7895    pub account_id: String,
7896    #[serde(rename = "availabilityZoneSuffixes", default)]
7897    pub availability_zone_suffixes: Vec<String>,
7898    #[serde(rename = "displayName", default)]
7899    pub display_name: String,
7900    #[serde(rename = "regionId", default)]
7901    pub region_id: ByocInfrastructurePostRequestRegionid,
7902    #[serde(rename = "vpcCidrRange", default)]
7903    pub vpc_cidr_range: String,
7904}
7905
7906/// `ClickPipe` from the ClickHouse Cloud API.
7907#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7908pub struct ClickPipe {
7909    #[serde(rename = "createdAt", default)]
7910    pub created_at: chrono::DateTime<chrono::Utc>,
7911    #[serde(default)]
7912    pub destination: ClickPipeDestination,
7913    #[serde(rename = "fieldMappings", default)]
7914    pub field_mappings: Vec<ClickPipeFieldMapping>,
7915    #[serde(default)]
7916    pub id: uuid::Uuid,
7917    #[serde(default)]
7918    pub name: String,
7919    #[serde(default)]
7920    pub scaling: ClickPipeScaling,
7921    #[serde(rename = "serviceId", default)]
7922    pub service_id: uuid::Uuid,
7923    #[serde(default)]
7924    pub settings: ClickPipeSettings,
7925    #[serde(default)]
7926    pub source: ClickPipeSource,
7927    #[serde(default)]
7928    pub state: ClickPipeState,
7929    #[serde(rename = "updatedAt", default)]
7930    pub updated_at: chrono::DateTime<chrono::Utc>,
7931}
7932
7933/// `ClickPipeBigQueryPipeSettings` from the ClickHouse Cloud API.
7934#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7935pub struct ClickPipeBigQueryPipeSettings {
7936    #[serde(rename = "allowNullableColumns", default)]
7937    pub allow_nullable_columns: bool,
7938    #[serde(rename = "initialLoadParallelism", default)]
7939    pub initial_load_parallelism: f64,
7940    #[serde(rename = "replicationMode", default)]
7941    pub replication_mode: ClickPipeBigQueryPipeSettingsReplicationmode,
7942    #[serde(rename = "snapshotNumRowsPerPartition", default)]
7943    pub snapshot_num_rows_per_partition: f64,
7944    #[serde(rename = "snapshotNumberOfParallelTables", default)]
7945    pub snapshot_number_of_parallel_tables: f64,
7946}
7947
7948/// `ClickPipeBigQueryPipeTableMapping` from the ClickHouse Cloud API.
7949#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7950pub struct ClickPipeBigQueryPipeTableMapping {
7951    #[serde(rename = "excludedColumns", default)]
7952    pub excluded_columns: Vec<String>,
7953    #[serde(rename = "sortingKeys", default)]
7954    pub sorting_keys: Vec<String>,
7955    #[serde(rename = "sourceDatasetName", default)]
7956    pub source_dataset_name: String,
7957    #[serde(rename = "sourceTable", default)]
7958    pub source_table: String,
7959    #[serde(rename = "tableEngine", default)]
7960    pub table_engine: ClickPipeBigQueryPipeTableMappingTableengine,
7961    #[serde(rename = "targetTable", default)]
7962    pub target_table: String,
7963    #[serde(rename = "useCustomSortingKey", default)]
7964    pub use_custom_sorting_key: bool,
7965}
7966
7967/// `ClickPipeBigQuerySource` from the ClickHouse Cloud API.
7968#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7969pub struct ClickPipeBigQuerySource {
7970    #[serde(default)]
7971    pub settings: ClickPipeBigQueryPipeSettings,
7972    #[serde(rename = "snapshotStagingPath", default)]
7973    pub snapshot_staging_path: String,
7974    #[serde(rename = "tableMappings", default)]
7975    pub table_mappings: Vec<ClickPipeBigQueryPipeTableMapping>,
7976}
7977
7978/// `ClickPipeDestination` from the ClickHouse Cloud API.
7979#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7980pub struct ClickPipeDestination {
7981    #[serde(default)]
7982    pub columns: Vec<ClickPipeDestinationColumn>,
7983    #[serde(default)]
7984    pub database: String,
7985    #[serde(rename = "managedTable", default)]
7986    pub managed_table: bool,
7987    #[serde(default)]
7988    pub table: String,
7989    #[serde(rename = "tableDefinition", default)]
7990    pub table_definition: ClickPipeDestinationTableDefinition,
7991}
7992
7993/// `ClickPipeDestinationColumn` from the ClickHouse Cloud API.
7994#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
7995pub struct ClickPipeDestinationColumn {
7996    #[serde(default)]
7997    pub name: String,
7998    #[serde(default)]
7999    pub r#type: String,
8000}
8001
8002/// `ClickPipeDestinationTableDefinition` from the ClickHouse Cloud API.
8003#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8004pub struct ClickPipeDestinationTableDefinition {
8005    #[serde(default)]
8006    pub engine: ClickPipeDestinationTableEngine,
8007    // API rejects empty strings / empty arrays for these keys. Spec has no
8008    // `required` array so the description-heuristic treats them as required;
8009    // skip at serialize time when unset instead of modeling as Option<T>.
8010    #[serde(rename = "partitionBy", skip_serializing_if = "String::is_empty", default)]
8011    pub partition_by: String,
8012    #[serde(rename = "primaryKey", skip_serializing_if = "String::is_empty", default)]
8013    pub primary_key: String,
8014    #[serde(rename = "sortingKey", skip_serializing_if = "Vec::is_empty", default)]
8015    pub sorting_key: Vec<String>,
8016}
8017
8018/// `ClickPipeDestinationTableEngine` from the ClickHouse Cloud API.
8019#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8020pub struct ClickPipeDestinationTableEngine {
8021    // columnIds only valid for SummingMergeTree. Skip when empty to avoid API
8022    // rejection for MergeTree/ReplacingMergeTree/Null engines. Spec has no
8023    // `required` array so the heuristic treats this as required; API rejects
8024    // empty values despite that.
8025    #[serde(rename = "columnIds", skip_serializing_if = "Vec::is_empty", default)]
8026    pub column_ids: Vec<String>,
8027    #[serde(default)]
8028    pub r#type: ClickPipeDestinationTableEngineType,
8029    #[serde(rename = "versionColumnId", skip_serializing_if = "Option::is_none", default)]
8030    pub version_column_id: Option<String>,
8031}
8032
8033/// `ClickPipeFieldMapping` from the ClickHouse Cloud API.
8034#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8035pub struct ClickPipeFieldMapping {
8036    #[serde(rename = "destinationField", default)]
8037    pub destination_field: String,
8038    #[serde(rename = "sourceField", default)]
8039    pub source_field: String,
8040}
8041
8042/// `ClickPipeKafkaOffset` from the ClickHouse Cloud API.
8043#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8044pub struct ClickPipeKafkaOffset {
8045    #[serde(default)]
8046    pub strategy: ClickPipeKafkaOffsetStrategy,
8047    #[serde(skip_serializing_if = "Option::is_none", default)]
8048    pub timestamp: Option<String>,
8049}
8050
8051/// `ClickPipeKafkaSchemaRegistry` from the ClickHouse Cloud API.
8052#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8053pub struct ClickPipeKafkaSchemaRegistry {
8054    #[serde(default)]
8055    pub authentication: ClickPipeKafkaSchemaRegistryAuthentication,
8056    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8057    pub ca_certificate: Option<String>,
8058    #[serde(default)]
8059    pub url: String,
8060}
8061
8062/// `ClickPipeKafkaSchemaRegistryCredentials` from the ClickHouse Cloud API.
8063#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8064pub struct ClickPipeKafkaSchemaRegistryCredentials {
8065    #[serde(default)]
8066    pub password: String,
8067    #[serde(default)]
8068    pub username: String,
8069}
8070
8071/// `ClickPipeKafkaSource` from the ClickHouse Cloud API.
8072#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8073pub struct ClickPipeKafkaSource {
8074    #[serde(default)]
8075    pub authentication: ClickPipeKafkaSourceAuthentication,
8076    #[serde(default)]
8077    pub brokers: String,
8078    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8079    pub ca_certificate: Option<String>,
8080    #[serde(rename = "consumerGroup", skip_serializing_if = "Option::is_none", default)]
8081    pub consumer_group: Option<String>,
8082    #[serde(default)]
8083    pub format: ClickPipeKafkaSourceFormat,
8084    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8085    pub iam_role: Option<String>,
8086    #[serde(skip_serializing_if = "Option::is_none", default)]
8087    pub offset: Option<ClickPipeKafkaOffset>,
8088    #[serde(rename = "reversePrivateEndpointIds", default, deserialize_with = "crate::serde_helpers::null_to_empty")]
8089    pub reverse_private_endpoint_ids: Vec<String>,
8090    #[serde(rename = "schemaRegistry", skip_serializing_if = "Option::is_none", default)]
8091    pub schema_registry: Option<ClickPipeKafkaSchemaRegistry>,
8092    #[serde(default)]
8093    pub topics: String,
8094    #[serde(default)]
8095    pub r#type: ClickPipeKafkaSourceType,
8096}
8097
8098/// `ClickPipeKinesisSource` from the ClickHouse Cloud API.
8099#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8100pub struct ClickPipeKinesisSource {
8101    #[serde(default)]
8102    pub authentication: ClickPipeKinesisSourceAuthentication,
8103    #[serde(default)]
8104    pub format: ClickPipeKinesisSourceFormat,
8105    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8106    pub iam_role: Option<String>,
8107    #[serde(rename = "iteratorType", default)]
8108    pub iterator_type: ClickPipeKinesisSourceIteratortype,
8109    #[serde(default)]
8110    pub region: String,
8111    #[serde(rename = "streamName", default)]
8112    pub stream_name: String,
8113    #[serde(skip_serializing_if = "Option::is_none", default)]
8114    pub timestamp: Option<i64>,
8115    #[serde(rename = "useEnhancedFanOut", skip_serializing_if = "Option::is_none", default)]
8116    pub use_enhanced_fan_out: Option<bool>,
8117}
8118
8119/// `ClickPipeMongoDBPipeSettings` from the ClickHouse Cloud API.
8120#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8121pub struct ClickPipeMongoDBPipeSettings {
8122    #[serde(rename = "deleteOnMerge", skip_serializing_if = "Option::is_none", default)]
8123    pub delete_on_merge: Option<bool>,
8124    #[serde(rename = "pullBatchSize", skip_serializing_if = "Option::is_none", default)]
8125    pub pull_batch_size: Option<i64>,
8126    #[serde(rename = "replicationMode")]
8127    pub replication_mode: ClickPipeMongoDBPipeSettingsReplicationmode,
8128    #[serde(rename = "snapshotNumRowsPerPartition", skip_serializing_if = "Option::is_none", default)]
8129    pub snapshot_num_rows_per_partition: Option<i64>,
8130    #[serde(rename = "snapshotNumberOfParallelTables", skip_serializing_if = "Option::is_none", default)]
8131    pub snapshot_number_of_parallel_tables: Option<i64>,
8132    #[serde(rename = "syncIntervalSeconds", skip_serializing_if = "Option::is_none", default)]
8133    pub sync_interval_seconds: Option<i64>,
8134    #[serde(rename = "useJsonNativeFormat", skip_serializing_if = "Option::is_none", default)]
8135    pub use_json_native_format: Option<bool>,
8136}
8137
8138/// `ClickPipeMongoDBPipeTableMapping` from the ClickHouse Cloud API.
8139#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8140pub struct ClickPipeMongoDBPipeTableMapping {
8141    #[serde(rename = "sourceCollection")]
8142    pub source_collection: String,
8143    #[serde(rename = "sourceDatabaseName")]
8144    pub source_database_name: String,
8145    #[serde(rename = "tableEngine", skip_serializing_if = "Option::is_none", default)]
8146    pub table_engine: Option<ClickPipeMongoDBPipeTableMappingTableengine>,
8147    #[serde(rename = "targetTable")]
8148    pub target_table: String,
8149}
8150
8151/// `ClickPipeMongoDBSource` from the ClickHouse Cloud API.
8152#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8153pub struct ClickPipeMongoDBSource {
8154    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8155    pub ca_certificate: Option<String>,
8156    #[serde(rename = "disableTls", skip_serializing_if = "Option::is_none", default)]
8157    pub disable_tls: Option<bool>,
8158    #[serde(rename = "readPreference")]
8159    pub read_preference: ClickPipeMongoDBSourceReadpreference,
8160    #[serde(skip_serializing_if = "Option::is_none", default)]
8161    pub settings: Option<ClickPipeMongoDBPipeSettings>,
8162    #[serde(rename = "tableMappings", skip_serializing_if = "Option::is_none", default)]
8163    pub table_mappings: Option<Vec<ClickPipeMongoDBPipeTableMapping>>,
8164    #[serde(rename = "tlsHost", skip_serializing_if = "Option::is_none", default)]
8165    pub tls_host: Option<String>,
8166    pub uri: String,
8167}
8168
8169/// `ClickPipeMutateBigQuerySource` from the ClickHouse Cloud API.
8170#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8171pub struct ClickPipeMutateBigQuerySource {
8172    #[serde(default)]
8173    pub credentials: ServiceAccount,
8174    #[serde(default)]
8175    pub settings: ClickPipeBigQueryPipeSettings,
8176    #[serde(rename = "snapshotStagingPath", default)]
8177    pub snapshot_staging_path: String,
8178    #[serde(rename = "tableMappings", default)]
8179    pub table_mappings: Vec<ClickPipeBigQueryPipeTableMapping>,
8180}
8181
8182/// `ClickPipeMutateDestination` from the ClickHouse Cloud API.
8183#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8184pub struct ClickPipeMutateDestination {
8185    // The spec describes `columns`, `managedTable`, `table`, and
8186    // `tableDefinition` as "Required field for all pipe types except database
8187    // pipes (Postgres, MySQL, BigQuery)" — all four must be omitted entirely
8188    // for database pipes. Modeled with skip-when-empty / Option so callers can
8189    // build a single destination type and database pipes serialize cleanly.
8190    #[serde(skip_serializing_if = "Vec::is_empty", default)]
8191    pub columns: Vec<ClickPipeDestinationColumn>,
8192    #[serde(default)]
8193    pub database: String,
8194    #[serde(rename = "managedTable", skip_serializing_if = "Option::is_none", default)]
8195    pub managed_table: Option<bool>,
8196    #[serde(skip_serializing_if = "Vec::is_empty", default)]
8197    pub roles: Vec<String>,
8198    #[serde(skip_serializing_if = "Option::is_none", default)]
8199    pub table: Option<String>,
8200    #[serde(rename = "tableDefinition", skip_serializing_if = "Option::is_none", default)]
8201    pub table_definition: Option<ClickPipeDestinationTableDefinition>,
8202}
8203
8204/// `ClickPipeMutateKafkaSchemaRegistry` from the ClickHouse Cloud API.
8205#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8206pub struct ClickPipeMutateKafkaSchemaRegistry {
8207    #[serde(default)]
8208    pub authentication: ClickPipeMutateKafkaSchemaRegistryAuthentication,
8209    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8210    pub ca_certificate: Option<String>,
8211    #[serde(default)]
8212    pub credentials: ClickPipeKafkaSchemaRegistryCredentials,
8213    #[serde(default)]
8214    pub url: String,
8215}
8216
8217/// `ClickPipeMutateMongoDBSource` from the ClickHouse Cloud API.
8218#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8219pub struct ClickPipeMutateMongoDBSource {
8220    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8221    pub ca_certificate: Option<String>,
8222    #[serde(skip_serializing_if = "Option::is_none", default)]
8223    pub credentials: Option<PLAIN>,
8224    #[serde(rename = "disableTls", skip_serializing_if = "Option::is_none", default)]
8225    pub disable_tls: Option<bool>,
8226    #[serde(rename = "readPreference")]
8227    pub read_preference: ClickPipeMutateMongoDBSourceReadpreference,
8228    pub settings: ClickPipeMongoDBPipeSettings,
8229    #[serde(rename = "tableMappings")]
8230    pub table_mappings: Vec<ClickPipeMongoDBPipeTableMapping>,
8231    #[serde(rename = "tlsHost", skip_serializing_if = "Option::is_none", default)]
8232    pub tls_host: Option<String>,
8233    pub uri: String,
8234}
8235
8236/// `ClickPipeMutateMySQLSource` from the ClickHouse Cloud API.
8237#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8238pub struct ClickPipeMutateMySQLSource {
8239    #[serde(skip_serializing_if = "Option::is_none", default)]
8240    pub authentication: Option<ClickPipeMutateMySQLSourceAuthentication>,
8241    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8242    pub ca_certificate: Option<String>,
8243    #[serde(skip_serializing_if = "Option::is_none", default)]
8244    pub credentials: Option<PLAIN>,
8245    #[serde(rename = "disableTls", skip_serializing_if = "Option::is_none", default)]
8246    pub disable_tls: Option<bool>,
8247    pub host: String,
8248    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8249    pub iam_role: Option<String>,
8250    pub port: i64,
8251    pub settings: ClickPipeMySQLPipeSettings,
8252    #[serde(rename = "skipCertVerification", skip_serializing_if = "Option::is_none", default)]
8253    pub skip_cert_verification: Option<bool>,
8254    #[serde(rename = "tableMappings")]
8255    pub table_mappings: Vec<ClickPipeMySQLPipeTableMapping>,
8256    #[serde(rename = "tlsHost", skip_serializing_if = "Option::is_none", default)]
8257    pub tls_host: Option<String>,
8258    #[serde(skip_serializing_if = "Option::is_none", default)]
8259    pub r#type: Option<ClickPipeMutateMySQLSourceType>,
8260}
8261
8262/// `ClickPipeMutatePostgresSource` from the ClickHouse Cloud API.
8263#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8264pub struct ClickPipeMutatePostgresSource {
8265    #[serde(default)]
8266    pub authentication: ClickPipeMutatePostgresSourceAuthentication,
8267    // caCertificate is `undefinedOr(isValidPEMCertificate)` server-side — sending
8268    // `""` (the bare-String default) fails PEM validation. Modeled as
8269    // `Option<String>` so callers can omit it.
8270    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8271    pub ca_certificate: Option<String>,
8272    #[serde(default)]
8273    pub credentials: PLAIN,
8274    #[serde(default)]
8275    pub database: String,
8276    #[serde(default)]
8277    pub host: String,
8278    // iamRole only applies to RDS-style Postgres + IAM_ROLE auth. Spec marks
8279    // it required but the server rejects "" for Basic-auth Postgres. Modeled
8280    // as Option<String> so callers can omit it; same pattern as ca_certificate.
8281    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8282    pub iam_role: Option<String>,
8283    #[serde(default)]
8284    pub port: i64,
8285    #[serde(default)]
8286    pub settings: ClickPipePostgresPipeSettings,
8287    #[serde(rename = "tableMappings", default)]
8288    pub table_mappings: Vec<ClickPipePostgresPipeTableMapping>,
8289    // tlsHost is only set when the broker cert SAN doesn't match `host`.
8290    // Optional in practice; server rejects "" with PEM-style validation.
8291    #[serde(rename = "tlsHost", skip_serializing_if = "Option::is_none", default)]
8292    pub tls_host: Option<String>,
8293    #[serde(skip_serializing_if = "Option::is_none", default)]
8294    pub r#type: Option<ClickPipeMutatePostgresSourceType>,
8295}
8296
8297/// `ClickPipeMySQLPipeSettings` from the ClickHouse Cloud API.
8298#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8299pub struct ClickPipeMySQLPipeSettings {
8300    #[serde(rename = "allowNullableColumns", skip_serializing_if = "Option::is_none", default)]
8301    pub allow_nullable_columns: Option<bool>,
8302    #[serde(rename = "deleteOnMerge", skip_serializing_if = "Option::is_none", default)]
8303    pub delete_on_merge: Option<bool>,
8304    #[serde(rename = "initialLoadParallelism", skip_serializing_if = "Option::is_none", default)]
8305    pub initial_load_parallelism: Option<i64>,
8306    #[serde(rename = "pullBatchSize", skip_serializing_if = "Option::is_none", default)]
8307    pub pull_batch_size: Option<i64>,
8308    #[serde(rename = "replicationMechanism", skip_serializing_if = "Option::is_none", default)]
8309    pub replication_mechanism: Option<ClickPipeMySQLPipeSettingsReplicationmechanism>,
8310    #[serde(rename = "replicationMode")]
8311    pub replication_mode: ClickPipeMySQLPipeSettingsReplicationmode,
8312    #[serde(rename = "snapshotNumRowsPerPartition", skip_serializing_if = "Option::is_none", default)]
8313    pub snapshot_num_rows_per_partition: Option<i64>,
8314    #[serde(rename = "snapshotNumberOfParallelTables", skip_serializing_if = "Option::is_none", default)]
8315    pub snapshot_number_of_parallel_tables: Option<i64>,
8316    #[serde(rename = "syncIntervalSeconds", skip_serializing_if = "Option::is_none", default)]
8317    pub sync_interval_seconds: Option<i64>,
8318    #[serde(rename = "useCompression", skip_serializing_if = "Option::is_none", default)]
8319    pub use_compression: Option<bool>,
8320}
8321
8322/// `ClickPipeMySQLPipeTableMapping` from the ClickHouse Cloud API.
8323#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8324pub struct ClickPipeMySQLPipeTableMapping {
8325    #[serde(rename = "excludedColumns", skip_serializing_if = "Option::is_none", default)]
8326    pub excluded_columns: Option<Vec<String>>,
8327    #[serde(rename = "partitionKey", skip_serializing_if = "Option::is_none", default)]
8328    pub partition_key: Option<String>,
8329    #[serde(rename = "sortingKeys", skip_serializing_if = "Option::is_none", default)]
8330    pub sorting_keys: Option<Vec<String>>,
8331    #[serde(rename = "sourceSchemaName")]
8332    pub source_schema_name: String,
8333    #[serde(rename = "sourceTable")]
8334    pub source_table: String,
8335    #[serde(rename = "tableEngine", skip_serializing_if = "Option::is_none", default)]
8336    pub table_engine: Option<ClickPipeMySQLPipeTableMappingTableengine>,
8337    #[serde(rename = "targetTable")]
8338    pub target_table: String,
8339    #[serde(rename = "useCustomSortingKey", skip_serializing_if = "Option::is_none", default)]
8340    pub use_custom_sorting_key: Option<bool>,
8341}
8342
8343/// `ClickPipeMySQLSource` from the ClickHouse Cloud API.
8344#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8345pub struct ClickPipeMySQLSource {
8346    #[serde(skip_serializing_if = "Option::is_none", default)]
8347    pub authentication: Option<ClickPipeMySQLSourceAuthentication>,
8348    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8349    pub ca_certificate: Option<String>,
8350    #[serde(rename = "disableTls", skip_serializing_if = "Option::is_none", default)]
8351    pub disable_tls: Option<bool>,
8352    pub host: String,
8353    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8354    pub iam_role: Option<String>,
8355    pub port: i64,
8356    pub settings: ClickPipeMySQLPipeSettings,
8357    #[serde(rename = "skipCertVerification", skip_serializing_if = "Option::is_none", default)]
8358    pub skip_cert_verification: Option<bool>,
8359    #[serde(rename = "tableMappings")]
8360    pub table_mappings: Vec<ClickPipeMySQLPipeTableMapping>,
8361    #[serde(rename = "tlsHost", skip_serializing_if = "Option::is_none", default)]
8362    pub tls_host: Option<String>,
8363    #[serde(skip_serializing_if = "Option::is_none", default)]
8364    pub r#type: Option<ClickPipeMySQLSourceType>,
8365}
8366
8367/// `ClickPipeObjectStorageSource` from the ClickHouse Cloud API.
8368#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8369pub struct ClickPipeObjectStorageSource {
8370    #[serde(skip_serializing_if = "Option::is_none", default)]
8371    pub authentication: Option<ClickPipeObjectStorageSourceAuthentication>,
8372    #[serde(rename = "azureContainerName", skip_serializing_if = "Option::is_none", default)]
8373    pub azure_container_name: Option<String>,
8374    #[serde(skip_serializing_if = "Option::is_none", default)]
8375    pub compression: Option<ClickPipeObjectStorageSourceCompression>,
8376    #[serde(rename = "connectionString", skip_serializing_if = "Option::is_none", default)]
8377    pub connection_string: Option<String>,
8378    #[serde(skip_serializing_if = "Option::is_none", default)]
8379    pub delimiter: Option<String>,
8380    #[serde(default)]
8381    pub format: ClickPipeObjectStorageSourceFormat,
8382    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8383    pub iam_role: Option<String>,
8384    #[serde(rename = "isContinuous", skip_serializing_if = "Option::is_none", default)]
8385    pub is_continuous: Option<bool>,
8386    #[serde(skip_serializing_if = "Option::is_none", default)]
8387    pub path: Option<String>,
8388    #[serde(rename = "queueUrl", skip_serializing_if = "Option::is_none", default)]
8389    pub queue_url: Option<String>,
8390    #[serde(default)]
8391    pub r#type: ClickPipeObjectStorageSourceType,
8392    #[serde(default)]
8393    pub url: String,
8394}
8395
8396/// `ClickPipePatchDestination` from the ClickHouse Cloud API.
8397#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8398pub struct ClickPipePatchDestination {
8399    #[serde(default)]
8400    pub columns: Vec<ClickPipeDestinationColumn>,
8401}
8402
8403/// `ClickPipePatchKafkaSource` from the ClickHouse Cloud API.
8404#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8405pub struct ClickPipePatchKafkaSource {
8406    #[serde(skip_serializing_if = "Option::is_none", default)]
8407    pub authentication: Option<ClickPipePatchKafkaSourceAuthentication>,
8408    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8409    pub ca_certificate: Option<String>,
8410    #[serde(default)]
8411    pub credentials: serde_json::Value,
8412    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8413    pub iam_role: Option<String>,
8414    #[serde(rename = "reversePrivateEndpointIds", default, deserialize_with = "crate::serde_helpers::null_to_empty")]
8415    pub reverse_private_endpoint_ids: Vec<String>,
8416}
8417
8418/// `ClickPipePatchKinesisSource` from the ClickHouse Cloud API.
8419#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8420pub struct ClickPipePatchKinesisSource {
8421    #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none", default)]
8422    pub access_key: Option<MskIamUser>,
8423    #[serde(skip_serializing_if = "Option::is_none", default)]
8424    pub authentication: Option<ClickPipePatchKinesisSourceAuthentication>,
8425    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8426    pub iam_role: Option<String>,
8427}
8428
8429/// `ClickPipePatchMongoDBPipeRemoveTableMapping` from the ClickHouse Cloud API.
8430#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8431pub struct ClickPipePatchMongoDBPipeRemoveTableMapping {
8432    #[serde(rename = "sourceCollection")]
8433    pub source_collection: Option<String>,
8434    #[serde(rename = "sourceDatabaseName")]
8435    pub source_database_name: Option<String>,
8436    #[serde(rename = "tableEngine", skip_serializing_if = "Option::is_none", default)]
8437    pub table_engine: Option<ClickPipePatchMongoDBPipeRemoveTableMappingTableengine>,
8438    #[serde(rename = "targetTable")]
8439    pub target_table: Option<String>,
8440}
8441
8442/// `ClickPipePatchMongoDBPipeSettings` from the ClickHouse Cloud API.
8443#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8444pub struct ClickPipePatchMongoDBPipeSettings {
8445    #[serde(rename = "pullBatchSize", skip_serializing_if = "Option::is_none", default)]
8446    pub pull_batch_size: Option<i64>,
8447    #[serde(rename = "syncIntervalSeconds", skip_serializing_if = "Option::is_none", default)]
8448    pub sync_interval_seconds: Option<i64>,
8449}
8450
8451/// `ClickPipePatchMongoDBSource` from the ClickHouse Cloud API.
8452#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8453pub struct ClickPipePatchMongoDBSource {
8454    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8455    pub ca_certificate: Option<String>,
8456    #[serde(skip_serializing_if = "Option::is_none", default)]
8457    pub credentials: Option<PLAIN>,
8458    #[serde(rename = "disableTls", skip_serializing_if = "Option::is_none", default)]
8459    pub disable_tls: Option<bool>,
8460    #[serde(rename = "readPreference", skip_serializing_if = "Option::is_none", default)]
8461    pub read_preference: Option<ClickPipePatchMongoDBSourceReadpreference>,
8462    #[serde(skip_serializing_if = "Option::is_none", default)]
8463    pub settings: Option<ClickPipePatchMongoDBPipeSettings>,
8464    #[serde(rename = "tableMappingsToAdd", skip_serializing_if = "Option::is_none", default)]
8465    pub table_mappings_to_add: Option<Vec<ClickPipeMongoDBPipeTableMapping>>,
8466    #[serde(rename = "tableMappingsToRemove", skip_serializing_if = "Option::is_none", default)]
8467    pub table_mappings_to_remove: Option<Vec<ClickPipePatchMongoDBPipeRemoveTableMapping>>,
8468    #[serde(rename = "tlsHost", skip_serializing_if = "Option::is_none", default)]
8469    pub tls_host: Option<String>,
8470    pub uri: Option<String>,
8471}
8472
8473/// `ClickPipePatchMySQLPipeRemoveTableMapping` from the ClickHouse Cloud API.
8474#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8475pub struct ClickPipePatchMySQLPipeRemoveTableMapping {
8476    #[serde(rename = "partitionKey", skip_serializing_if = "Option::is_none", default)]
8477    pub partition_key: Option<String>,
8478    #[serde(rename = "sourceSchemaName")]
8479    pub source_schema_name: Option<String>,
8480    #[serde(rename = "sourceTable")]
8481    pub source_table: Option<String>,
8482    #[serde(rename = "tableEngine", skip_serializing_if = "Option::is_none", default)]
8483    pub table_engine: Option<ClickPipePatchMySQLPipeRemoveTableMappingTableengine>,
8484    #[serde(rename = "targetTable")]
8485    pub target_table: Option<String>,
8486}
8487
8488/// `ClickPipePatchMySQLPipeSettings` from the ClickHouse Cloud API.
8489#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8490pub struct ClickPipePatchMySQLPipeSettings {
8491    #[serde(rename = "pullBatchSize", skip_serializing_if = "Option::is_none", default)]
8492    pub pull_batch_size: Option<i64>,
8493    #[serde(rename = "syncIntervalSeconds", skip_serializing_if = "Option::is_none", default)]
8494    pub sync_interval_seconds: Option<i64>,
8495    #[serde(rename = "useCompression", skip_serializing_if = "Option::is_none", default)]
8496    pub use_compression: Option<bool>,
8497}
8498
8499/// `ClickPipePatchMySQLSource` from the ClickHouse Cloud API.
8500#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8501pub struct ClickPipePatchMySQLSource {
8502    #[serde(skip_serializing_if = "Option::is_none", default)]
8503    pub authentication: Option<ClickPipePatchMySQLSourceAuthentication>,
8504    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8505    pub ca_certificate: Option<String>,
8506    #[serde(skip_serializing_if = "Option::is_none", default)]
8507    pub credentials: Option<PLAIN>,
8508    #[serde(rename = "disableTls", skip_serializing_if = "Option::is_none", default)]
8509    pub disable_tls: Option<bool>,
8510    pub host: Option<String>,
8511    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8512    pub iam_role: Option<String>,
8513    pub port: Option<i64>,
8514    #[serde(skip_serializing_if = "Option::is_none", default)]
8515    pub settings: Option<ClickPipePatchMySQLPipeSettings>,
8516    #[serde(rename = "skipCertVerification", skip_serializing_if = "Option::is_none", default)]
8517    pub skip_cert_verification: Option<bool>,
8518    #[serde(rename = "tableMappingsToAdd", skip_serializing_if = "Option::is_none", default)]
8519    pub table_mappings_to_add: Option<Vec<ClickPipeMySQLPipeTableMapping>>,
8520    #[serde(rename = "tableMappingsToRemove", skip_serializing_if = "Option::is_none", default)]
8521    pub table_mappings_to_remove: Option<Vec<ClickPipePatchMySQLPipeRemoveTableMapping>>,
8522    #[serde(rename = "tlsHost", skip_serializing_if = "Option::is_none", default)]
8523    pub tls_host: Option<String>,
8524}
8525
8526/// `ClickPipePatchObjectStorageSource` from the ClickHouse Cloud API.
8527#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8528pub struct ClickPipePatchObjectStorageSource {
8529    #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none", default)]
8530    pub access_key: Option<MskIamUser>,
8531    #[serde(skip_serializing_if = "Option::is_none", default)]
8532    pub authentication: Option<ClickPipePatchObjectStorageSourceAuthentication>,
8533    #[serde(rename = "azureContainerName", skip_serializing_if = "Option::is_none", default)]
8534    pub azure_container_name: Option<String>,
8535    #[serde(rename = "connectionString", skip_serializing_if = "Option::is_none", default)]
8536    pub connection_string: Option<String>,
8537    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8538    pub iam_role: Option<String>,
8539    #[serde(skip_serializing_if = "Option::is_none", default)]
8540    pub path: Option<String>,
8541    #[serde(rename = "serviceAccountKey", skip_serializing_if = "Option::is_none", default)]
8542    pub service_account_key: Option<String>,
8543}
8544
8545/// `ClickPipePatchPostgresPipeRemoveTableMapping` from the ClickHouse Cloud API.
8546#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8547pub struct ClickPipePatchPostgresPipeRemoveTableMapping {
8548    #[serde(rename = "partitionKey", skip_serializing_if = "Option::is_none", default)]
8549    pub partition_key: Option<String>,
8550    #[serde(rename = "sourceSchemaName", skip_serializing_if = "Option::is_none", default)]
8551    pub source_schema_name: Option<String>,
8552    #[serde(rename = "sourceTable", skip_serializing_if = "Option::is_none", default)]
8553    pub source_table: Option<String>,
8554    #[serde(rename = "tableEngine", skip_serializing_if = "Option::is_none", default)]
8555    pub table_engine: Option<ClickPipePatchPostgresPipeRemoveTableMappingTableengine>,
8556    #[serde(rename = "targetTable", skip_serializing_if = "Option::is_none", default)]
8557    pub target_table: Option<String>,
8558}
8559
8560/// `ClickPipePatchPostgresPipeSettings` from the ClickHouse Cloud API.
8561#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8562pub struct ClickPipePatchPostgresPipeSettings {
8563    #[serde(rename = "pullBatchSize", skip_serializing_if = "Option::is_none", default)]
8564    pub pull_batch_size: Option<i64>,
8565    #[serde(rename = "syncIntervalSeconds", skip_serializing_if = "Option::is_none", default)]
8566    pub sync_interval_seconds: Option<i64>,
8567}
8568
8569/// `ClickPipePatchPostgresSource` from the ClickHouse Cloud API.
8570#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8571pub struct ClickPipePatchPostgresSource {
8572    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8573    pub ca_certificate: Option<String>,
8574    #[serde(default)]
8575    pub credentials: PLAIN,
8576    #[serde(skip_serializing_if = "Option::is_none", default)]
8577    pub database: Option<String>,
8578    #[serde(skip_serializing_if = "Option::is_none", default)]
8579    pub host: Option<String>,
8580    #[serde(skip_serializing_if = "Option::is_none", default)]
8581    pub port: Option<i64>,
8582    #[serde(default)]
8583    pub settings: ClickPipePatchPostgresPipeSettings,
8584    #[serde(rename = "tableMappingsToAdd", default)]
8585    pub table_mappings_to_add: Vec<ClickPipePostgresPipeTableMapping>,
8586    #[serde(rename = "tableMappingsToRemove", default)]
8587    pub table_mappings_to_remove: Vec<ClickPipePatchPostgresPipeRemoveTableMapping>,
8588    #[serde(rename = "tlsHost", skip_serializing_if = "Option::is_none", default)]
8589    pub tls_host: Option<String>,
8590}
8591
8592/// `ClickPipePatchPubSubSource` from the ClickHouse Cloud API.
8593#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8594pub struct ClickPipePatchPubSubSource {
8595    #[serde(rename = "ackDeadline", skip_serializing_if = "Option::is_none", default)]
8596    pub ack_deadline: Option<i64>,
8597    pub authentication: Option<ClickPipePatchPubSubSourceAuthentication>,
8598    #[serde(rename = "serviceAccountKey")]
8599    pub service_account_key: Option<ServiceAccount>,
8600}
8601
8602/// `ClickPipePatchRequest` from the ClickHouse Cloud API.
8603#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8604pub struct ClickPipePatchRequest {
8605    #[serde(skip_serializing_if = "Option::is_none", default)]
8606    pub destination: Option<ClickPipePatchDestination>,
8607    #[serde(rename = "fieldMappings", skip_serializing_if = "Option::is_none", default)]
8608    pub field_mappings: Option<Vec<ClickPipeFieldMapping>>,
8609    #[serde(skip_serializing_if = "Option::is_none", default)]
8610    pub name: Option<String>,
8611    #[serde(skip_serializing_if = "Option::is_none", default)]
8612    pub settings: Option<ClickPipeSettings>,
8613    #[serde(skip_serializing_if = "Option::is_none", default)]
8614    pub source: Option<ClickPipePatchSource>,
8615}
8616
8617/// `ClickPipePatchSource` from the ClickHouse Cloud API.
8618#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8619pub struct ClickPipePatchSource {
8620    #[serde(skip_serializing_if = "Option::is_none", default)]
8621    pub kafka: Option<ClickPipePatchKafkaSource>,
8622    #[serde(skip_serializing_if = "Option::is_none", default)]
8623    pub kinesis: Option<ClickPipePatchKinesisSource>,
8624    #[serde(skip_serializing_if = "Option::is_none", default)]
8625    pub mongodb: Option<ClickPipePatchMongoDBSource>,
8626    #[serde(skip_serializing_if = "Option::is_none", default)]
8627    pub mysql: Option<ClickPipePatchMySQLSource>,
8628    #[serde(rename = "objectStorage", skip_serializing_if = "Option::is_none", default)]
8629    pub object_storage: Option<ClickPipePatchObjectStorageSource>,
8630    #[serde(skip_serializing_if = "Option::is_none", default)]
8631    pub postgres: Option<ClickPipePatchPostgresSource>,
8632    #[serde(skip_serializing_if = "Option::is_none", default)]
8633    pub pubsub: Option<ClickPipePatchPubSubSource>,
8634    #[serde(rename = "validateSamples", default)]
8635    pub validate_samples: bool,
8636}
8637
8638/// `ClickPipePostKafkaSource` from the ClickHouse Cloud API.
8639#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8640pub struct ClickPipePostKafkaSource {
8641    #[serde(default)]
8642    pub authentication: ClickPipePostKafkaSourceAuthentication,
8643    #[serde(default)]
8644    pub brokers: String,
8645    #[serde(rename = "caCertificate", skip_serializing_if = "Option::is_none", default)]
8646    pub ca_certificate: Option<String>,
8647    #[serde(rename = "consumerGroup", skip_serializing_if = "Option::is_none", default)]
8648    pub consumer_group: Option<String>,
8649    #[serde(default)]
8650    pub credentials: serde_json::Value,
8651    #[serde(default)]
8652    pub format: ClickPipePostKafkaSourceFormat,
8653    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8654    pub iam_role: Option<String>,
8655    #[serde(skip_serializing_if = "Option::is_none", default)]
8656    pub offset: Option<ClickPipeKafkaOffset>,
8657    #[serde(rename = "reversePrivateEndpointIds", default, deserialize_with = "crate::serde_helpers::null_to_empty")]
8658    pub reverse_private_endpoint_ids: Vec<String>,
8659    #[serde(rename = "schemaRegistry", skip_serializing_if = "Option::is_none", default)]
8660    pub schema_registry: Option<ClickPipeMutateKafkaSchemaRegistry>,
8661    #[serde(default)]
8662    pub topics: String,
8663    #[serde(default)]
8664    pub r#type: ClickPipePostKafkaSourceType,
8665}
8666
8667/// `ClickPipePostKinesisSource` from the ClickHouse Cloud API.
8668#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8669pub struct ClickPipePostKinesisSource {
8670    #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none", default)]
8671    pub access_key: Option<MskIamUser>,
8672    #[serde(default)]
8673    pub authentication: ClickPipePostKinesisSourceAuthentication,
8674    #[serde(default)]
8675    pub format: ClickPipePostKinesisSourceFormat,
8676    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8677    pub iam_role: Option<String>,
8678    #[serde(rename = "iteratorType", default)]
8679    pub iterator_type: ClickPipePostKinesisSourceIteratortype,
8680    #[serde(default)]
8681    pub region: String,
8682    #[serde(rename = "streamName", default)]
8683    pub stream_name: String,
8684    #[serde(skip_serializing_if = "Option::is_none", default)]
8685    pub timestamp: Option<i64>,
8686    #[serde(rename = "useEnhancedFanOut", skip_serializing_if = "Option::is_none", default)]
8687    pub use_enhanced_fan_out: Option<bool>,
8688}
8689
8690/// `ClickPipePostObjectStorageSource` from the ClickHouse Cloud API.
8691#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8692pub struct ClickPipePostObjectStorageSource {
8693    #[serde(rename = "accessKey", skip_serializing_if = "Option::is_none", default)]
8694    pub access_key: Option<MskIamUser>,
8695    #[serde(skip_serializing_if = "Option::is_none", default)]
8696    pub authentication: Option<ClickPipePostObjectStorageSourceAuthentication>,
8697    #[serde(rename = "azureContainerName", skip_serializing_if = "Option::is_none", default)]
8698    pub azure_container_name: Option<String>,
8699    #[serde(skip_serializing_if = "Option::is_none", default)]
8700    pub compression: Option<ClickPipePostObjectStorageSourceCompression>,
8701    #[serde(rename = "connectionString", skip_serializing_if = "Option::is_none", default)]
8702    pub connection_string: Option<String>,
8703    #[serde(skip_serializing_if = "Option::is_none", default)]
8704    pub delimiter: Option<String>,
8705    #[serde(default)]
8706    pub format: ClickPipePostObjectStorageSourceFormat,
8707    #[serde(rename = "iamRole", skip_serializing_if = "Option::is_none", default)]
8708    pub iam_role: Option<String>,
8709    #[serde(rename = "isContinuous", skip_serializing_if = "Option::is_none", default)]
8710    pub is_continuous: Option<bool>,
8711    #[serde(skip_serializing_if = "Option::is_none", default)]
8712    pub path: Option<String>,
8713    #[serde(rename = "queueUrl", skip_serializing_if = "Option::is_none", default)]
8714    pub queue_url: Option<String>,
8715    #[serde(rename = "serviceAccountKey", skip_serializing_if = "Option::is_none", default)]
8716    pub service_account_key: Option<String>,
8717    #[serde(default)]
8718    pub r#type: ClickPipePostObjectStorageSourceType,
8719    #[serde(default)]
8720    pub url: String,
8721}
8722
8723/// `ClickPipePostPubSubSource` from the ClickHouse Cloud API.
8724#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8725pub struct ClickPipePostPubSubSource {
8726    #[serde(rename = "ackDeadline", skip_serializing_if = "Option::is_none", default)]
8727    pub ack_deadline: Option<i64>,
8728    pub authentication: ClickPipePostPubSubSourceAuthentication,
8729    #[serde(rename = "enableOrdering", skip_serializing_if = "Option::is_none", default)]
8730    pub enable_ordering: Option<bool>,
8731    #[serde(skip_serializing_if = "Option::is_none", default)]
8732    pub filter: Option<String>,
8733    pub format: ClickPipePostPubSubSourceFormat,
8734    #[serde(rename = "projectId")]
8735    pub project_id: String,
8736    #[serde(rename = "seekSnapshot", skip_serializing_if = "Option::is_none", default)]
8737    pub seek_snapshot: Option<String>,
8738    #[serde(rename = "seekTimestamp", skip_serializing_if = "Option::is_none", default)]
8739    pub seek_timestamp: Option<chrono::DateTime<chrono::Utc>>,
8740    #[serde(rename = "seekType")]
8741    pub seek_type: ClickPipePostPubSubSourceSeektype,
8742    #[serde(rename = "serviceAccountKey")]
8743    pub service_account_key: ServiceAccount,
8744    pub topic: String,
8745}
8746
8747/// `ClickPipePostRequest` from the ClickHouse Cloud API.
8748#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8749pub struct ClickPipePostRequest {
8750    #[serde(default)]
8751    pub destination: ClickPipeMutateDestination,
8752    // Empty arrays rejected by some API paths and never useful on create —
8753    // skip when empty. Non-Option to match the spec description heuristic.
8754    #[serde(rename = "fieldMappings", skip_serializing_if = "Vec::is_empty", default)]
8755    pub field_mappings: Vec<ClickPipeFieldMapping>,
8756    #[serde(default)]
8757    pub name: String,
8758    // scaling block default-serializes as {replicas: 0, ...} which the API
8759    // rejects ("replicas: Not between 1 and 40"). Modeled as Option so the
8760    // whole block is omitted when the caller doesn't set it.
8761    #[serde(skip_serializing_if = "Option::is_none", default)]
8762    pub scaling: Option<ClickPipeScaling>,
8763    // settings default-serializes as `{}` which the API also rejects.
8764    #[serde(skip_serializing_if = "Option::is_none", default)]
8765    pub settings: Option<ClickPipeSettings>,
8766    #[serde(default)]
8767    pub source: ClickPipePostSource,
8768}
8769
8770/// `ClickPipePostSource` from the ClickHouse Cloud API.
8771#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8772pub struct ClickPipePostSource {
8773    #[serde(skip_serializing_if = "Option::is_none", default)]
8774    pub bigquery: Option<ClickPipeMutateBigQuerySource>,
8775    #[serde(skip_serializing_if = "Option::is_none", default)]
8776    pub kafka: Option<ClickPipePostKafkaSource>,
8777    #[serde(skip_serializing_if = "Option::is_none", default)]
8778    pub kinesis: Option<ClickPipePostKinesisSource>,
8779    #[serde(skip_serializing_if = "Option::is_none", default)]
8780    pub mongodb: Option<ClickPipeMutateMongoDBSource>,
8781    #[serde(skip_serializing_if = "Option::is_none", default)]
8782    pub mysql: Option<ClickPipeMutateMySQLSource>,
8783    #[serde(rename = "objectStorage", skip_serializing_if = "Option::is_none", default)]
8784    pub object_storage: Option<ClickPipePostObjectStorageSource>,
8785    #[serde(skip_serializing_if = "Option::is_none", default)]
8786    pub postgres: Option<ClickPipeMutatePostgresSource>,
8787    #[serde(skip_serializing_if = "Option::is_none", default)]
8788    pub pubsub: Option<ClickPipePostPubSubSource>,
8789    #[serde(rename = "validateSamples", default)]
8790    pub validate_samples: bool,
8791}
8792
8793/// `ClickPipePostgresPipeSettings` from the ClickHouse Cloud API.
8794#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8795pub struct ClickPipePostgresPipeSettings {
8796    #[serde(rename = "allowNullableColumns", default)]
8797    pub allow_nullable_columns: bool,
8798    #[serde(rename = "deleteOnMerge", default)]
8799    pub delete_on_merge: bool,
8800    #[serde(rename = "enableFailoverSlots", default)]
8801    pub enable_failover_slots: bool,
8802    #[serde(rename = "initialLoadParallelism", skip_serializing_if = "Option::is_none", default)]
8803    pub initial_load_parallelism: Option<i64>,
8804    #[serde(rename = "publicationName", skip_serializing_if = "Option::is_none", default)]
8805    pub publication_name: Option<String>,
8806    #[serde(rename = "pullBatchSize", skip_serializing_if = "Option::is_none", default)]
8807    pub pull_batch_size: Option<i64>,
8808    #[serde(rename = "replicationMode", default)]
8809    pub replication_mode: ClickPipePostgresPipeSettingsReplicationmode,
8810    #[serde(rename = "replicationSlotName", skip_serializing_if = "Option::is_none", default)]
8811    pub replication_slot_name: Option<String>,
8812    #[serde(rename = "snapshotNumRowsPerPartition", skip_serializing_if = "Option::is_none", default)]
8813    pub snapshot_num_rows_per_partition: Option<i64>,
8814    #[serde(rename = "snapshotNumberOfParallelTables", skip_serializing_if = "Option::is_none", default)]
8815    pub snapshot_number_of_parallel_tables: Option<i64>,
8816    #[serde(rename = "syncIntervalSeconds", skip_serializing_if = "Option::is_none", default)]
8817    pub sync_interval_seconds: Option<i64>,
8818}
8819
8820/// `ClickPipePostgresPipeTableMapping` from the ClickHouse Cloud API.
8821#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8822pub struct ClickPipePostgresPipeTableMapping {
8823    #[serde(rename = "excludedColumns", default)]
8824    pub excluded_columns: Vec<String>,
8825    #[serde(rename = "partitionKey", default)]
8826    pub partition_key: String,
8827    #[serde(rename = "sortingKeys", default)]
8828    pub sorting_keys: Vec<String>,
8829    #[serde(rename = "sourceSchemaName", default)]
8830    pub source_schema_name: String,
8831    #[serde(rename = "sourceTable", default)]
8832    pub source_table: String,
8833    #[serde(rename = "tableEngine", default)]
8834    pub table_engine: ClickPipePostgresPipeTableMappingTableengine,
8835    #[serde(rename = "targetTable", default)]
8836    pub target_table: String,
8837    #[serde(rename = "useCustomSortingKey", default)]
8838    pub use_custom_sorting_key: bool,
8839}
8840
8841/// `ClickPipePostgresSource` from the ClickHouse Cloud API.
8842#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8843pub struct ClickPipePostgresSource {
8844    #[serde(default)]
8845    pub authentication: ClickPipePostgresSourceAuthentication,
8846    #[serde(rename = "caCertificate", default)]
8847    pub ca_certificate: String,
8848    #[serde(default)]
8849    pub database: String,
8850    #[serde(default)]
8851    pub host: String,
8852    #[serde(rename = "iamRole", default)]
8853    pub iam_role: String,
8854    #[serde(default)]
8855    pub port: i64,
8856    #[serde(default)]
8857    pub settings: ClickPipePostgresPipeSettings,
8858    #[serde(rename = "tableMappings", default)]
8859    pub table_mappings: Vec<ClickPipePostgresPipeTableMapping>,
8860    #[serde(rename = "tlsHost", default)]
8861    pub tls_host: String,
8862    #[serde(skip_serializing_if = "Option::is_none", default)]
8863    pub r#type: Option<ClickPipePostgresSourceType>,
8864}
8865
8866/// `ClickPipePubSubSource` from the ClickHouse Cloud API.
8867#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8868pub struct ClickPipePubSubSource {
8869    #[serde(rename = "ackDeadline", skip_serializing_if = "Option::is_none", default)]
8870    pub ack_deadline: Option<i64>,
8871    pub authentication: ClickPipePubSubSourceAuthentication,
8872    #[serde(rename = "enableOrdering", skip_serializing_if = "Option::is_none", default)]
8873    pub enable_ordering: Option<bool>,
8874    #[serde(skip_serializing_if = "Option::is_none", default)]
8875    pub filter: Option<String>,
8876    pub format: ClickPipePubSubSourceFormat,
8877    #[serde(rename = "projectId")]
8878    pub project_id: String,
8879    #[serde(rename = "seekSnapshot", skip_serializing_if = "Option::is_none", default)]
8880    pub seek_snapshot: Option<String>,
8881    #[serde(rename = "seekTimestamp", skip_serializing_if = "Option::is_none", default)]
8882    pub seek_timestamp: Option<chrono::DateTime<chrono::Utc>>,
8883    #[serde(rename = "seekType")]
8884    pub seek_type: ClickPipePubSubSourceSeektype,
8885    pub topic: String,
8886}
8887
8888/// `ClickPipeScaling` from the ClickHouse Cloud API.
8889#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8890pub struct ClickPipeScaling {
8891    #[cfg(feature = "deprecated-fields")]
8892    #[serde(default)]
8893    pub concurrency: i64,
8894    #[serde(rename = "replicaCpuMillicores", default)]
8895    pub replica_cpu_millicores: i64,
8896    #[serde(rename = "replicaMemoryGb", default)]
8897    pub replica_memory_gb: f64,
8898    #[serde(default)]
8899    pub replicas: i64,
8900}
8901
8902/// `ClickPipeScalingPatchRequest` from the ClickHouse Cloud API.
8903#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8904pub struct ClickPipeScalingPatchRequest {
8905    #[cfg(feature = "deprecated-fields")]
8906    #[serde(skip_serializing_if = "Option::is_none", default)]
8907    pub concurrency: Option<i64>,
8908    #[serde(rename = "replicaCpuMillicores", skip_serializing_if = "Option::is_none", default)]
8909    pub replica_cpu_millicores: Option<i64>,
8910    #[serde(rename = "replicaMemoryGb", skip_serializing_if = "Option::is_none", default)]
8911    pub replica_memory_gb: Option<f64>,
8912    #[serde(skip_serializing_if = "Option::is_none", default)]
8913    pub replicas: Option<i64>,
8914}
8915
8916/// `ClickPipeSettings` from the ClickHouse Cloud API.
8917#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8918pub struct ClickPipeSettings {
8919    #[serde(skip_serializing_if = "Option::is_none", default)]
8920    pub clickhouse_max_download_threads: Option<i64>,
8921    #[serde(skip_serializing_if = "Option::is_none", default)]
8922    pub clickhouse_max_insert_threads: Option<i64>,
8923    #[serde(skip_serializing_if = "Option::is_none", default)]
8924    pub clickhouse_max_threads: Option<i64>,
8925    #[serde(skip_serializing_if = "Option::is_none", default)]
8926    pub clickhouse_min_insert_block_size_bytes: Option<i64>,
8927    #[serde(skip_serializing_if = "Option::is_none", default)]
8928    pub clickhouse_parallel_distributed_insert_select: Option<i64>,
8929    #[serde(skip_serializing_if = "Option::is_none", default)]
8930    pub clickhouse_parallel_view_processing: Option<bool>,
8931    #[serde(skip_serializing_if = "Option::is_none", default)]
8932    pub object_storage_concurrency: Option<i64>,
8933    #[serde(skip_serializing_if = "Option::is_none", default)]
8934    pub object_storage_max_file_count: Option<i64>,
8935    #[serde(skip_serializing_if = "Option::is_none", default)]
8936    pub object_storage_max_insert_bytes: Option<i64>,
8937    #[serde(skip_serializing_if = "Option::is_none", default)]
8938    pub object_storage_polling_interval_ms: Option<i64>,
8939    #[serde(skip_serializing_if = "Option::is_none", default)]
8940    pub object_storage_use_cluster_function: Option<bool>,
8941    #[serde(skip_serializing_if = "Option::is_none", default)]
8942    pub streaming_max_insert_wait_ms: Option<i64>,
8943}
8944
8945/// `ClickPipeSettingsPutRequest` from the ClickHouse Cloud API.
8946#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8947pub struct ClickPipeSettingsPutRequest {
8948    #[serde(skip_serializing_if = "Option::is_none", default)]
8949    pub clickhouse_max_download_threads: Option<i64>,
8950    #[serde(skip_serializing_if = "Option::is_none", default)]
8951    pub clickhouse_max_insert_threads: Option<i64>,
8952    #[serde(skip_serializing_if = "Option::is_none", default)]
8953    pub clickhouse_max_threads: Option<i64>,
8954    #[serde(skip_serializing_if = "Option::is_none", default)]
8955    pub clickhouse_min_insert_block_size_bytes: Option<i64>,
8956    #[serde(skip_serializing_if = "Option::is_none", default)]
8957    pub clickhouse_parallel_distributed_insert_select: Option<i64>,
8958    #[serde(skip_serializing_if = "Option::is_none", default)]
8959    pub clickhouse_parallel_view_processing: Option<bool>,
8960    #[serde(skip_serializing_if = "Option::is_none", default)]
8961    pub object_storage_concurrency: Option<i64>,
8962    #[serde(skip_serializing_if = "Option::is_none", default)]
8963    pub object_storage_max_file_count: Option<i64>,
8964    #[serde(skip_serializing_if = "Option::is_none", default)]
8965    pub object_storage_max_insert_bytes: Option<i64>,
8966    #[serde(skip_serializing_if = "Option::is_none", default)]
8967    pub object_storage_polling_interval_ms: Option<i64>,
8968    #[serde(skip_serializing_if = "Option::is_none", default)]
8969    pub object_storage_use_cluster_function: Option<bool>,
8970    #[serde(skip_serializing_if = "Option::is_none", default)]
8971    pub streaming_max_insert_wait_ms: Option<i64>,
8972}
8973
8974/// `ClickPipeSource` from the ClickHouse Cloud API.
8975#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8976pub struct ClickPipeSource {
8977    #[serde(skip_serializing_if = "Option::is_none", default)]
8978    pub bigquery: Option<ClickPipeBigQuerySource>,
8979    #[serde(skip_serializing_if = "Option::is_none", default)]
8980    pub kafka: Option<ClickPipeKafkaSource>,
8981    #[serde(skip_serializing_if = "Option::is_none", default)]
8982    pub kinesis: Option<ClickPipeKinesisSource>,
8983    #[serde(skip_serializing_if = "Option::is_none", default)]
8984    pub mongodb: Option<ClickPipeMongoDBSource>,
8985    #[serde(skip_serializing_if = "Option::is_none", default)]
8986    pub mysql: Option<ClickPipeMySQLSource>,
8987    #[serde(rename = "objectStorage", skip_serializing_if = "Option::is_none", default)]
8988    pub object_storage: Option<ClickPipeObjectStorageSource>,
8989    #[serde(skip_serializing_if = "Option::is_none", default)]
8990    pub postgres: Option<ClickPipePostgresSource>,
8991    #[serde(skip_serializing_if = "Option::is_none", default)]
8992    pub pubsub: Option<ClickPipePubSubSource>,
8993}
8994
8995/// `ClickPipeStatePatchRequest` from the ClickHouse Cloud API.
8996#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
8997pub struct ClickPipeStatePatchRequest {
8998    #[serde(skip_serializing_if = "Option::is_none", default)]
8999    pub command: Option<ClickPipeStatePatchRequestCommand>,
9000}
9001
9002/// `ClickPipesCdcScaling` from the ClickHouse Cloud API.
9003#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9004pub struct ClickPipesCdcScaling {
9005    #[serde(rename = "replicaCpuMillicores", default)]
9006    pub replica_cpu_millicores: i64,
9007    #[serde(rename = "replicaMemoryGb", default)]
9008    pub replica_memory_gb: f64,
9009}
9010
9011/// `ClickPipesCdcScalingPatchRequest` from the ClickHouse Cloud API.
9012#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9013pub struct ClickPipesCdcScalingPatchRequest {
9014    #[serde(rename = "replicaCpuMillicores", skip_serializing_if = "Option::is_none", default)]
9015    pub replica_cpu_millicores: Option<i64>,
9016    #[serde(rename = "replicaMemoryGb", skip_serializing_if = "Option::is_none", default)]
9017    pub replica_memory_gb: Option<f64>,
9018}
9019
9020/// `ClickStackAggregatedColumn` from the ClickHouse Cloud API.
9021#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9022pub struct ClickStackAggregatedColumn {
9023    #[serde(rename = "aggFn")]
9024    pub agg_fn: String,
9025    #[serde(rename = "mvColumn")]
9026    pub mv_column: String,
9027    #[serde(rename = "sourceColumn", skip_serializing_if = "Option::is_none", default)]
9028    pub source_column: Option<String>,
9029}
9030
9031/// `ClickStackAlertChannelEmail` from the ClickHouse Cloud API.
9032#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9033pub struct ClickStackAlertChannelEmail {
9034    #[serde(rename = "emailRecipients")]
9035    pub email_recipients: Vec<String>,
9036    pub r#type: ClickStackAlertChannelEmailType,
9037}
9038
9039/// `ClickStackAlertChannelWebhook` from the ClickHouse Cloud API.
9040#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9041pub struct ClickStackAlertChannelWebhook {
9042    #[serde(skip_serializing_if = "Option::is_none", default)]
9043    pub severity: Option<ClickStackAlertChannelWebhookSeverity>,
9044    #[serde(rename = "slackChannelId", skip_serializing_if = "Option::is_none", default)]
9045    pub slack_channel_id: Option<String>,
9046    pub r#type: ClickStackAlertChannelWebhookType,
9047    #[serde(rename = "webhookId")]
9048    pub webhook_id: String,
9049    #[serde(rename = "webhookService", skip_serializing_if = "Option::is_none", default)]
9050    pub webhook_service: Option<String>,
9051}
9052
9053/// `ClickStackAlertExecutionError` from the ClickHouse Cloud API.
9054#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9055pub struct ClickStackAlertExecutionError {
9056    #[serde(default)]
9057    pub message: String,
9058    #[serde(default)]
9059    pub timestamp: chrono::DateTime<chrono::Utc>,
9060    #[serde(default)]
9061    pub r#type: ClickStackAlertExecutionErrorType,
9062}
9063
9064/// `ClickStackAlertResponse` from the ClickHouse Cloud API.
9065#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9066pub struct ClickStackAlertResponse {
9067    #[serde(default)]
9068    pub channel: ClickStackAlertChannel,
9069    #[serde(rename = "createdAt", skip_serializing_if = "Option::is_none", default)]
9070    pub created_at: Option<chrono::DateTime<chrono::Utc>>,
9071    #[serde(rename = "dashboardId", skip_serializing_if = "Option::is_none", default)]
9072    pub dashboard_id: Option<String>,
9073    #[serde(rename = "executionErrors", default)]
9074    pub execution_errors: Vec<ClickStackAlertExecutionError>,
9075    #[serde(rename = "groupBy", skip_serializing_if = "Option::is_none", default)]
9076    pub group_by: Option<String>,
9077    #[serde(default)]
9078    pub id: String,
9079    #[serde(default)]
9080    pub interval: ClickStackAlertResponseInterval,
9081    #[serde(skip_serializing_if = "Option::is_none", default)]
9082    pub message: Option<String>,
9083    #[serde(skip_serializing_if = "Option::is_none", default)]
9084    pub name: Option<String>,
9085    #[serde(skip_serializing_if = "Option::is_none", default)]
9086    pub note: Option<String>,
9087    #[serde(rename = "savedSearchId", skip_serializing_if = "Option::is_none", default)]
9088    pub saved_search_id: Option<String>,
9089    #[serde(rename = "scheduleOffsetMinutes", skip_serializing_if = "Option::is_none", default)]
9090    pub schedule_offset_minutes: Option<i64>,
9091    #[serde(rename = "scheduleStartAt", skip_serializing_if = "Option::is_none", default)]
9092    pub schedule_start_at: Option<chrono::DateTime<chrono::Utc>>,
9093    #[serde(skip_serializing_if = "Option::is_none", default)]
9094    pub silenced: Option<ClickStackAlertSilenced>,
9095    #[serde(default)]
9096    pub source: ClickStackAlertResponseSource,
9097    #[serde(default)]
9098    pub state: ClickStackAlertResponseState,
9099    #[serde(rename = "teamId", default)]
9100    pub team_id: String,
9101    #[serde(default)]
9102    pub threshold: f64,
9103    #[serde(rename = "thresholdMax", skip_serializing_if = "Option::is_none", default)]
9104    pub threshold_max: Option<f64>,
9105    #[serde(rename = "thresholdType", default)]
9106    pub threshold_type: ClickStackAlertResponseThresholdtype,
9107    #[serde(rename = "tileId", skip_serializing_if = "Option::is_none", default)]
9108    pub tile_id: Option<String>,
9109    #[serde(rename = "updatedAt", skip_serializing_if = "Option::is_none", default)]
9110    pub updated_at: Option<chrono::DateTime<chrono::Utc>>,
9111}
9112
9113/// `ClickStackAlertSilenced` from the ClickHouse Cloud API.
9114#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9115pub struct ClickStackAlertSilenced {
9116    #[serde(default)]
9117    pub at: chrono::DateTime<chrono::Utc>,
9118    #[serde(skip_serializing_if = "Option::is_none", default)]
9119    pub by: Option<String>,
9120    #[serde(default)]
9121    pub until: chrono::DateTime<chrono::Utc>,
9122}
9123
9124/// `ClickStackBarBuilderChartConfig` from the ClickHouse Cloud API.
9125#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9126pub struct ClickStackBarBuilderChartConfig {
9127    #[serde(rename = "alignDateRangeToGranularity", skip_serializing_if = "Option::is_none", default)]
9128    pub align_date_range_to_granularity: Option<bool>,
9129    #[serde(rename = "asRatio", skip_serializing_if = "Option::is_none", default)]
9130    pub as_ratio: Option<bool>,
9131    #[serde(rename = "displayType")]
9132    pub display_type: ClickStackBarBuilderChartConfigDisplaytype,
9133    #[serde(rename = "fillNulls", skip_serializing_if = "Option::is_none", default)]
9134    pub fill_nulls: Option<bool>,
9135    #[serde(rename = "groupBy", skip_serializing_if = "Option::is_none", default)]
9136    pub group_by: Option<String>,
9137    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9138    pub number_format: Option<ClickStackNumberFormat>,
9139    pub select: Vec<ClickStackSelectItem>,
9140    #[serde(rename = "sourceId")]
9141    pub source_id: String,
9142}
9143
9144/// `ClickStackBarRawSqlChartConfig` from the ClickHouse Cloud API.
9145#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9146pub struct ClickStackBarRawSqlChartConfig {
9147    #[serde(rename = "alignDateRangeToGranularity", skip_serializing_if = "Option::is_none", default)]
9148    pub align_date_range_to_granularity: Option<bool>,
9149    #[serde(rename = "configType")]
9150    pub config_type: ClickStackBarRawSqlChartConfigConfigtype,
9151    #[serde(rename = "connectionId")]
9152    pub connection_id: String,
9153    #[serde(rename = "displayType")]
9154    pub display_type: ClickStackBarRawSqlChartConfigDisplaytype,
9155    #[serde(rename = "fillNulls", skip_serializing_if = "Option::is_none", default)]
9156    pub fill_nulls: Option<bool>,
9157    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9158    pub number_format: Option<ClickStackNumberFormat>,
9159    #[serde(rename = "sourceId", skip_serializing_if = "Option::is_none", default)]
9160    pub source_id: Option<String>,
9161    #[serde(rename = "sqlTemplate")]
9162    pub sql_template: String,
9163}
9164
9165/// `ClickStackCreateAlertRequest` from the ClickHouse Cloud API.
9166#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9167pub struct ClickStackCreateAlertRequest {
9168    #[serde(default)]
9169    pub channel: ClickStackAlertChannel,
9170    #[serde(rename = "dashboardId", skip_serializing_if = "Option::is_none", default)]
9171    pub dashboard_id: Option<String>,
9172    #[serde(rename = "groupBy", skip_serializing_if = "Option::is_none", default)]
9173    pub group_by: Option<String>,
9174    #[serde(default)]
9175    pub interval: ClickStackCreateAlertRequestInterval,
9176    #[serde(skip_serializing_if = "Option::is_none", default)]
9177    pub message: Option<String>,
9178    #[serde(skip_serializing_if = "Option::is_none", default)]
9179    pub name: Option<String>,
9180    #[serde(skip_serializing_if = "Option::is_none", default)]
9181    pub note: Option<String>,
9182    #[serde(rename = "savedSearchId", skip_serializing_if = "Option::is_none", default)]
9183    pub saved_search_id: Option<String>,
9184    #[serde(rename = "scheduleOffsetMinutes", skip_serializing_if = "Option::is_none", default)]
9185    pub schedule_offset_minutes: Option<i64>,
9186    #[serde(rename = "scheduleStartAt", skip_serializing_if = "Option::is_none", default)]
9187    pub schedule_start_at: Option<chrono::DateTime<chrono::Utc>>,
9188    #[serde(default)]
9189    pub source: ClickStackCreateAlertRequestSource,
9190    #[serde(default)]
9191    pub threshold: f64,
9192    #[serde(rename = "thresholdMax", skip_serializing_if = "Option::is_none", default)]
9193    pub threshold_max: Option<f64>,
9194    #[serde(rename = "thresholdType", default)]
9195    pub threshold_type: ClickStackCreateAlertRequestThresholdtype,
9196    #[serde(rename = "tileId", skip_serializing_if = "Option::is_none", default)]
9197    pub tile_id: Option<String>,
9198}
9199
9200/// `ClickStackCreateDashboardRequest` from the ClickHouse Cloud API.
9201#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9202pub struct ClickStackCreateDashboardRequest {
9203    #[serde(skip_serializing_if = "Option::is_none", default)]
9204    pub containers: Option<Vec<ClickStackDashboardContainer>>,
9205    #[serde(skip_serializing_if = "Option::is_none", default)]
9206    pub filters: Option<Vec<ClickStackFilterInput>>,
9207    pub name: String,
9208    #[serde(rename = "savedFilterValues", skip_serializing_if = "Option::is_none", default)]
9209    pub saved_filter_values: Option<Vec<ClickStackSavedFilterValue>>,
9210    #[serde(rename = "savedQuery", skip_serializing_if = "Option::is_none", default)]
9211    pub saved_query: Option<String>,
9212    #[serde(rename = "savedQueryLanguage", skip_serializing_if = "Option::is_none", default)]
9213    pub saved_query_language: Option<ClickStackCreateDashboardRequestSavedquerylanguage>,
9214    #[serde(skip_serializing_if = "Option::is_none", default)]
9215    pub tags: Option<Vec<String>>,
9216    pub tiles: Vec<ClickStackTileInput>,
9217}
9218
9219/// `ClickStackDashboardContainer` from the ClickHouse Cloud API.
9220#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9221pub struct ClickStackDashboardContainer {
9222    #[serde(skip_serializing_if = "Option::is_none", default)]
9223    pub bordered: Option<bool>,
9224    pub collapsed: bool,
9225    #[serde(skip_serializing_if = "Option::is_none", default)]
9226    pub collapsible: Option<bool>,
9227    pub id: String,
9228    #[serde(skip_serializing_if = "Option::is_none", default)]
9229    pub tabs: Option<Vec<ClickStackDashboardContainerTab>>,
9230    pub title: String,
9231}
9232
9233/// `ClickStackDashboardContainerTab` from the ClickHouse Cloud API.
9234#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9235pub struct ClickStackDashboardContainerTab {
9236    pub id: String,
9237    pub title: String,
9238}
9239
9240/// `ClickStackDashboardResponse` from the ClickHouse Cloud API.
9241#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9242pub struct ClickStackDashboardResponse {
9243    #[serde(skip_serializing_if = "Option::is_none", default)]
9244    pub containers: Option<Vec<ClickStackDashboardContainer>>,
9245    #[serde(default)]
9246    pub filters: Vec<ClickStackFilter>,
9247    #[serde(default)]
9248    pub id: String,
9249    #[serde(default)]
9250    pub name: String,
9251    #[serde(rename = "savedFilterValues", skip_serializing_if = "Option::is_none", default)]
9252    pub saved_filter_values: Option<Vec<ClickStackSavedFilterValue>>,
9253    #[serde(rename = "savedQuery", skip_serializing_if = "Option::is_none", default)]
9254    pub saved_query: Option<String>,
9255    #[serde(rename = "savedQueryLanguage", skip_serializing_if = "Option::is_none", default)]
9256    pub saved_query_language: Option<ClickStackDashboardResponseSavedquerylanguage>,
9257    #[serde(default)]
9258    pub tags: Vec<String>,
9259    #[serde(default)]
9260    pub tiles: Vec<ClickStackTileOutput>,
9261}
9262
9263/// `ClickStackFilter` from the ClickHouse Cloud API.
9264#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9265pub struct ClickStackFilter {
9266    pub expression: String,
9267    pub id: String,
9268    pub name: String,
9269    #[serde(rename = "sourceId")]
9270    pub source_id: String,
9271    #[serde(rename = "sourceMetricType", skip_serializing_if = "Option::is_none", default)]
9272    pub source_metric_type: Option<ClickStackFilterSourcemetrictype>,
9273    pub r#type: ClickStackFilterType,
9274    #[serde(skip_serializing_if = "Option::is_none", default)]
9275    pub r#where: Option<String>,
9276    #[serde(rename = "whereLanguage", skip_serializing_if = "Option::is_none", default)]
9277    pub where_language: Option<ClickStackFilterWherelanguage>,
9278}
9279
9280/// `ClickStackFilterInput` from the ClickHouse Cloud API.
9281#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9282pub struct ClickStackFilterInput {
9283    pub expression: String,
9284    pub name: String,
9285    #[serde(rename = "sourceId")]
9286    pub source_id: String,
9287    #[serde(rename = "sourceMetricType", skip_serializing_if = "Option::is_none", default)]
9288    pub source_metric_type: Option<ClickStackFilterInputSourcemetrictype>,
9289    pub r#type: ClickStackFilterInputType,
9290    #[serde(skip_serializing_if = "Option::is_none", default)]
9291    pub r#where: Option<String>,
9292    #[serde(rename = "whereLanguage", skip_serializing_if = "Option::is_none", default)]
9293    pub where_language: Option<ClickStackFilterInputWherelanguage>,
9294}
9295
9296/// `ClickStackFilterSettingsColumn` from the ClickHouse Cloud API.
9297#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9298pub struct ClickStackFilterSettingsColumn {
9299    pub label: String,
9300    pub name: String,
9301}
9302
9303/// `ClickStackGenericWebhook` from the ClickHouse Cloud API.
9304#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9305pub struct ClickStackGenericWebhook {
9306    #[serde(skip_serializing_if = "Option::is_none", default)]
9307    pub body: Option<String>,
9308    #[serde(rename = "createdAt")]
9309    pub created_at: chrono::DateTime<chrono::Utc>,
9310    #[serde(skip_serializing_if = "Option::is_none", default)]
9311    pub description: Option<String>,
9312    pub id: String,
9313    pub name: String,
9314    pub service: ClickStackGenericWebhookService,
9315    #[serde(rename = "updatedAt")]
9316    pub updated_at: chrono::DateTime<chrono::Utc>,
9317    #[serde(skip_serializing_if = "Option::is_none", default)]
9318    pub url: Option<String>,
9319}
9320
9321/// `ClickStackHeatmapChartConfig` from the ClickHouse Cloud API.
9322#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9323pub struct ClickStackHeatmapChartConfig {
9324    #[serde(rename = "displayType")]
9325    pub display_type: ClickStackHeatmapChartConfigDisplaytype,
9326    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9327    pub number_format: Option<ClickStackNumberFormat>,
9328    pub select: Vec<ClickStackHeatmapSelectItem>,
9329    #[serde(rename = "sourceId")]
9330    pub source_id: String,
9331    #[serde(rename = "where", skip_serializing_if = "Option::is_none", default)]
9332    pub r#where: Option<String>,
9333    #[serde(rename = "whereLanguage", skip_serializing_if = "Option::is_none", default)]
9334    pub where_language: Option<ClickStackHeatmapChartConfigWherelanguage>,
9335}
9336
9337/// `ClickStackHeatmapSelectItem` from the ClickHouse Cloud API.
9338#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9339pub struct ClickStackHeatmapSelectItem {
9340    #[serde(rename = "countExpression", skip_serializing_if = "Option::is_none", default)]
9341    pub count_expression: Option<String>,
9342    #[serde(rename = "heatmapScaleType", skip_serializing_if = "Option::is_none", default)]
9343    pub heatmap_scale_type: Option<ClickStackHeatmapSelectItemHeatmapscaletype>,
9344    #[serde(rename = "valueExpression")]
9345    pub value_expression: String,
9346}
9347
9348/// `ClickStackHighlightedAttributeExpression` from the ClickHouse Cloud API.
9349#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9350pub struct ClickStackHighlightedAttributeExpression {
9351    #[serde(skip_serializing_if = "Option::is_none", default)]
9352    pub alias: Option<String>,
9353    #[serde(rename = "luceneExpression", skip_serializing_if = "Option::is_none", default)]
9354    pub lucene_expression: Option<String>,
9355    #[serde(rename = "sqlExpression")]
9356    pub sql_expression: String,
9357}
9358
9359/// `ClickStackIncidentIOWebhook` from the ClickHouse Cloud API.
9360#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9361pub struct ClickStackIncidentIOWebhook {
9362    #[serde(rename = "createdAt")]
9363    pub created_at: chrono::DateTime<chrono::Utc>,
9364    #[serde(skip_serializing_if = "Option::is_none", default)]
9365    pub description: Option<String>,
9366    pub id: String,
9367    pub name: String,
9368    pub service: ClickStackIncidentIOWebhookService,
9369    #[serde(rename = "updatedAt")]
9370    pub updated_at: chrono::DateTime<chrono::Utc>,
9371    #[serde(skip_serializing_if = "Option::is_none", default)]
9372    pub url: Option<String>,
9373}
9374
9375/// `ClickStackLineBuilderChartConfig` from the ClickHouse Cloud API.
9376#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9377pub struct ClickStackLineBuilderChartConfig {
9378    #[serde(rename = "alignDateRangeToGranularity", skip_serializing_if = "Option::is_none", default)]
9379    pub align_date_range_to_granularity: Option<bool>,
9380    #[serde(rename = "asRatio", skip_serializing_if = "Option::is_none", default)]
9381    pub as_ratio: Option<bool>,
9382    #[serde(rename = "compareToPreviousPeriod", skip_serializing_if = "Option::is_none", default)]
9383    pub compare_to_previous_period: Option<bool>,
9384    #[serde(rename = "displayType")]
9385    pub display_type: ClickStackLineBuilderChartConfigDisplaytype,
9386    #[serde(rename = "fillNulls", skip_serializing_if = "Option::is_none", default)]
9387    pub fill_nulls: Option<bool>,
9388    #[serde(rename = "groupBy", skip_serializing_if = "Option::is_none", default)]
9389    pub group_by: Option<String>,
9390    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9391    pub number_format: Option<ClickStackNumberFormat>,
9392    pub select: Vec<ClickStackSelectItem>,
9393    #[serde(rename = "sourceId")]
9394    pub source_id: String,
9395}
9396
9397/// `ClickStackLineRawSqlChartConfig` from the ClickHouse Cloud API.
9398#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9399pub struct ClickStackLineRawSqlChartConfig {
9400    #[serde(rename = "alignDateRangeToGranularity", skip_serializing_if = "Option::is_none", default)]
9401    pub align_date_range_to_granularity: Option<bool>,
9402    #[serde(rename = "compareToPreviousPeriod", skip_serializing_if = "Option::is_none", default)]
9403    pub compare_to_previous_period: Option<bool>,
9404    #[serde(rename = "configType")]
9405    pub config_type: ClickStackLineRawSqlChartConfigConfigtype,
9406    #[serde(rename = "connectionId")]
9407    pub connection_id: String,
9408    #[serde(rename = "displayType")]
9409    pub display_type: ClickStackLineRawSqlChartConfigDisplaytype,
9410    #[serde(rename = "fillNulls", skip_serializing_if = "Option::is_none", default)]
9411    pub fill_nulls: Option<bool>,
9412    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9413    pub number_format: Option<ClickStackNumberFormat>,
9414    #[serde(rename = "sourceId", skip_serializing_if = "Option::is_none", default)]
9415    pub source_id: Option<String>,
9416    #[serde(rename = "sqlTemplate")]
9417    pub sql_template: String,
9418}
9419
9420/// `ClickStackLogSource` from the ClickHouse Cloud API.
9421#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9422pub struct ClickStackLogSource {
9423    #[serde(rename = "bodyExpression", skip_serializing_if = "Option::is_none", default)]
9424    pub body_expression: Option<String>,
9425    pub connection: String,
9426    #[serde(rename = "defaultTableSelectExpression")]
9427    pub default_table_select_expression: String,
9428    #[serde(rename = "displayedTimestampValueExpression", skip_serializing_if = "Option::is_none", default)]
9429    pub displayed_timestamp_value_expression: Option<String>,
9430    #[serde(rename = "eventAttributesExpression", skip_serializing_if = "Option::is_none", default)]
9431    pub event_attributes_expression: Option<String>,
9432    #[serde(rename = "filterSettings", skip_serializing_if = "Option::is_none", default)]
9433    pub filter_settings: Option<ClickStackSourceFilterSettings>,
9434    pub from: ClickStackSourceFrom,
9435    #[serde(rename = "highlightedRowAttributeExpressions", skip_serializing_if = "Option::is_none", default)]
9436    pub highlighted_row_attribute_expressions: Option<Vec<ClickStackHighlightedAttributeExpression>>,
9437    #[serde(rename = "highlightedTraceAttributeExpressions", skip_serializing_if = "Option::is_none", default)]
9438    pub highlighted_trace_attribute_expressions: Option<Vec<ClickStackHighlightedAttributeExpression>>,
9439    pub id: String,
9440    #[serde(rename = "implicitColumnExpression", skip_serializing_if = "Option::is_none", default)]
9441    pub implicit_column_expression: Option<String>,
9442    pub kind: ClickStackLogSourceKind,
9443    #[serde(rename = "materializedViews", skip_serializing_if = "Option::is_none", default)]
9444    pub materialized_views: Option<Vec<ClickStackMaterializedView>>,
9445    #[serde(rename = "metadataMaterializedViews", skip_serializing_if = "Option::is_none", default)]
9446    pub metadata_materialized_views: Option<ClickStackLogSourceMetadataMaterializedViews>,
9447    #[serde(rename = "metricSourceId", skip_serializing_if = "Option::is_none", default)]
9448    pub metric_source_id: Option<String>,
9449    pub name: String,
9450    #[serde(rename = "querySettings", skip_serializing_if = "Option::is_none", default)]
9451    pub query_settings: Option<Vec<ClickStackQuerySetting>>,
9452    #[serde(rename = "resourceAttributesExpression", skip_serializing_if = "Option::is_none", default)]
9453    pub resource_attributes_expression: Option<String>,
9454    #[serde(rename = "serviceNameExpression", skip_serializing_if = "Option::is_none", default)]
9455    pub service_name_expression: Option<String>,
9456    #[serde(rename = "severityTextExpression", skip_serializing_if = "Option::is_none", default)]
9457    pub severity_text_expression: Option<String>,
9458    #[serde(rename = "spanIdExpression", skip_serializing_if = "Option::is_none", default)]
9459    pub span_id_expression: Option<String>,
9460    #[serde(rename = "timestampValueExpression")]
9461    pub timestamp_value_expression: String,
9462    #[serde(rename = "traceIdExpression", skip_serializing_if = "Option::is_none", default)]
9463    pub trace_id_expression: Option<String>,
9464    #[serde(rename = "traceSourceId", skip_serializing_if = "Option::is_none", default)]
9465    pub trace_source_id: Option<String>,
9466}
9467
9468/// `ClickStackLogSourceMetadataMaterializedViews` from the ClickHouse Cloud API.
9469#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9470pub struct ClickStackLogSourceMetadataMaterializedViews {
9471    #[serde(default)]
9472    pub granularity: String,
9473    #[serde(rename = "keyRollupTable", default)]
9474    pub key_rollup_table: String,
9475    #[serde(rename = "kvRollupTable", default)]
9476    pub kv_rollup_table: String,
9477}
9478
9479/// `ClickStackMarkdownChartConfig` from the ClickHouse Cloud API.
9480#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9481pub struct ClickStackMarkdownChartConfig {
9482    #[serde(rename = "displayType")]
9483    pub display_type: ClickStackMarkdownChartConfigDisplaytype,
9484    #[serde(skip_serializing_if = "Option::is_none", default)]
9485    pub markdown: Option<String>,
9486}
9487
9488/// `ClickStackMarkdownChartSeries` from the ClickHouse Cloud API.
9489#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9490pub struct ClickStackMarkdownChartSeries {
9491    pub content: String,
9492    pub r#type: ClickStackMarkdownChartSeriesType,
9493}
9494
9495/// `ClickStackMaterializedView` from the ClickHouse Cloud API.
9496#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9497pub struct ClickStackMaterializedView {
9498    #[serde(rename = "aggregatedColumns")]
9499    pub aggregated_columns: Vec<ClickStackAggregatedColumn>,
9500    #[serde(rename = "databaseName")]
9501    pub database_name: String,
9502    #[serde(rename = "dimensionColumns")]
9503    pub dimension_columns: String,
9504    #[serde(rename = "minDate", skip_serializing_if = "Option::is_none", default)]
9505    pub min_date: Option<chrono::DateTime<chrono::Utc>>,
9506    #[serde(rename = "minGranularity")]
9507    pub min_granularity: ClickStackMaterializedViewMingranularity,
9508    #[serde(rename = "tableName")]
9509    pub table_name: String,
9510    #[serde(rename = "timestampColumn")]
9511    pub timestamp_column: String,
9512}
9513
9514/// `ClickStackMetricSource` from the ClickHouse Cloud API.
9515#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9516pub struct ClickStackMetricSource {
9517    pub connection: String,
9518    pub from: ClickStackMetricSourceFrom,
9519    pub id: String,
9520    pub kind: ClickStackMetricSourceKind,
9521    #[serde(rename = "logSourceId", skip_serializing_if = "Option::is_none", default)]
9522    pub log_source_id: Option<String>,
9523    #[serde(rename = "metricTables")]
9524    pub metric_tables: ClickStackMetricTables,
9525    pub name: String,
9526    #[serde(rename = "querySettings", skip_serializing_if = "Option::is_none", default)]
9527    pub query_settings: Option<Vec<ClickStackQuerySetting>>,
9528    #[serde(rename = "resourceAttributesExpression")]
9529    pub resource_attributes_expression: String,
9530    #[serde(rename = "timestampValueExpression")]
9531    pub timestamp_value_expression: String,
9532}
9533
9534/// `ClickStackMetricSourceFrom` from the ClickHouse Cloud API.
9535#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9536pub struct ClickStackMetricSourceFrom {
9537    #[serde(rename = "databaseName")]
9538    pub database_name: String,
9539    #[serde(rename = "tableName", skip_serializing_if = "Option::is_none", default)]
9540    pub table_name: Option<String>,
9541}
9542
9543/// `ClickStackMetricTables` from the ClickHouse Cloud API.
9544#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9545pub struct ClickStackMetricTables {
9546    #[serde(rename = "exponential histogram", default)]
9547    pub exponential_histogram: String,
9548    #[serde(default)]
9549    pub gauge: String,
9550    #[serde(default)]
9551    pub histogram: String,
9552    #[serde(default)]
9553    pub sum: String,
9554    #[serde(default)]
9555    pub summary: String,
9556}
9557
9558/// `ClickStackNumberBuilderChartConfig` from the ClickHouse Cloud API.
9559#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9560pub struct ClickStackNumberBuilderChartConfig {
9561    #[serde(rename = "displayType")]
9562    pub display_type: ClickStackNumberBuilderChartConfigDisplaytype,
9563    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9564    pub number_format: Option<ClickStackNumberFormat>,
9565    pub select: Vec<ClickStackSelectItem>,
9566    #[serde(rename = "sourceId")]
9567    pub source_id: String,
9568}
9569
9570/// `ClickStackNumberChartSeries` from the ClickHouse Cloud API.
9571#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9572pub struct ClickStackNumberChartSeries {
9573    #[serde(rename = "aggFn")]
9574    pub agg_fn: ClickStackNumberChartSeriesAggfn,
9575    #[serde(skip_serializing_if = "Option::is_none", default)]
9576    pub alias: Option<String>,
9577    #[serde(skip_serializing_if = "Option::is_none", default)]
9578    pub field: Option<String>,
9579    #[serde(skip_serializing_if = "Option::is_none", default)]
9580    pub level: Option<f64>,
9581    #[serde(rename = "metricDataType", skip_serializing_if = "Option::is_none", default)]
9582    pub metric_data_type: Option<ClickStackNumberChartSeriesMetricdatatype>,
9583    #[serde(rename = "metricName", skip_serializing_if = "Option::is_none", default)]
9584    pub metric_name: Option<String>,
9585    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9586    pub number_format: Option<ClickStackNumberFormat>,
9587    #[serde(rename = "sourceId")]
9588    pub source_id: String,
9589    pub r#type: ClickStackNumberChartSeriesType,
9590    pub r#where: String,
9591    #[serde(rename = "whereLanguage")]
9592    pub where_language: ClickStackNumberChartSeriesWherelanguage,
9593}
9594
9595/// `ClickStackNumberFormat` from the ClickHouse Cloud API.
9596#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9597pub struct ClickStackNumberFormat {
9598    #[serde(default)]
9599    pub average: bool,
9600    #[serde(rename = "currencySymbol", default)]
9601    pub currency_symbol: String,
9602    #[serde(rename = "decimalBytes", default)]
9603    pub decimal_bytes: bool,
9604    #[serde(default)]
9605    pub factor: f64,
9606    #[serde(default)]
9607    pub mantissa: i64,
9608    #[serde(rename = "numericUnit", default)]
9609    pub numeric_unit: ClickStackNumberFormatNumericunit,
9610    #[serde(default)]
9611    pub output: ClickStackNumberFormatOutput,
9612    #[serde(rename = "thousandSeparated", default)]
9613    pub thousand_separated: bool,
9614    #[serde(default)]
9615    pub unit: String,
9616}
9617
9618/// `ClickStackNumberRawSqlChartConfig` from the ClickHouse Cloud API.
9619#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9620pub struct ClickStackNumberRawSqlChartConfig {
9621    #[serde(rename = "configType")]
9622    pub config_type: ClickStackNumberRawSqlChartConfigConfigtype,
9623    #[serde(rename = "connectionId")]
9624    pub connection_id: String,
9625    #[serde(rename = "displayType")]
9626    pub display_type: ClickStackNumberRawSqlChartConfigDisplaytype,
9627    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9628    pub number_format: Option<ClickStackNumberFormat>,
9629    #[serde(rename = "sourceId", skip_serializing_if = "Option::is_none", default)]
9630    pub source_id: Option<String>,
9631    #[serde(rename = "sqlTemplate")]
9632    pub sql_template: String,
9633}
9634
9635/// `ClickStackOnClickDashboard` from the ClickHouse Cloud API.
9636#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9637pub struct ClickStackOnClickDashboard {
9638    #[serde(skip_serializing_if = "Option::is_none", default)]
9639    pub filters: Option<Vec<ClickStackOnClickFilterTemplate>>,
9640    pub target: ClickStackOnClickTarget,
9641    pub r#type: ClickStackOnClickDashboardType,
9642    #[serde(rename = "whereLanguage", skip_serializing_if = "Option::is_none", default)]
9643    pub where_language: Option<ClickStackOnClickDashboardWherelanguage>,
9644    #[serde(rename = "whereTemplate", skip_serializing_if = "Option::is_none", default)]
9645    pub where_template: Option<String>,
9646}
9647
9648/// `ClickStackOnClickFilterTemplate` from the ClickHouse Cloud API.
9649#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9650pub struct ClickStackOnClickFilterTemplate {
9651    pub expression: String,
9652    pub kind: ClickStackOnClickFilterTemplateKind,
9653    pub template: String,
9654}
9655
9656/// `ClickStackOnClickSearch` from the ClickHouse Cloud API.
9657#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9658pub struct ClickStackOnClickSearch {
9659    #[serde(skip_serializing_if = "Option::is_none", default)]
9660    pub filters: Option<Vec<ClickStackOnClickFilterTemplate>>,
9661    pub target: ClickStackOnClickTarget,
9662    pub r#type: ClickStackOnClickSearchType,
9663    #[serde(rename = "whereLanguage", skip_serializing_if = "Option::is_none", default)]
9664    pub where_language: Option<ClickStackOnClickSearchWherelanguage>,
9665    #[serde(rename = "whereTemplate", skip_serializing_if = "Option::is_none", default)]
9666    pub where_template: Option<String>,
9667}
9668
9669/// `ClickStackOnClickTargetIdVariant` from the ClickHouse Cloud API.
9670#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9671pub struct ClickStackOnClickTargetIdVariant {
9672    pub id: String,
9673    pub mode: ClickStackOnClickTargetIdVariantMode,
9674}
9675
9676/// `ClickStackOnClickTargetTemplateVariant` from the ClickHouse Cloud API.
9677#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9678pub struct ClickStackOnClickTargetTemplateVariant {
9679    pub mode: ClickStackOnClickTargetTemplateVariantMode,
9680    pub template: String,
9681}
9682
9683/// `ClickStackPagerDutyAPIWebhook` from the ClickHouse Cloud API.
9684#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9685pub struct ClickStackPagerDutyAPIWebhook {
9686    #[serde(rename = "createdAt")]
9687    pub created_at: chrono::DateTime<chrono::Utc>,
9688    #[serde(skip_serializing_if = "Option::is_none", default)]
9689    pub description: Option<String>,
9690    pub id: String,
9691    pub name: String,
9692    pub service: ClickStackPagerDutyAPIWebhookService,
9693    #[serde(rename = "updatedAt")]
9694    pub updated_at: chrono::DateTime<chrono::Utc>,
9695    #[serde(skip_serializing_if = "Option::is_none", default)]
9696    pub url: Option<String>,
9697}
9698
9699/// `ClickStackPieBuilderChartConfig` from the ClickHouse Cloud API.
9700#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9701pub struct ClickStackPieBuilderChartConfig {
9702    #[serde(rename = "displayType")]
9703    pub display_type: ClickStackPieBuilderChartConfigDisplaytype,
9704    #[serde(rename = "groupBy", skip_serializing_if = "Option::is_none", default)]
9705    pub group_by: Option<String>,
9706    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9707    pub number_format: Option<ClickStackNumberFormat>,
9708    pub select: Vec<ClickStackSelectItem>,
9709    #[serde(rename = "sourceId")]
9710    pub source_id: String,
9711}
9712
9713/// `ClickStackPieRawSqlChartConfig` from the ClickHouse Cloud API.
9714#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9715pub struct ClickStackPieRawSqlChartConfig {
9716    #[serde(rename = "configType")]
9717    pub config_type: ClickStackPieRawSqlChartConfigConfigtype,
9718    #[serde(rename = "connectionId")]
9719    pub connection_id: String,
9720    #[serde(rename = "displayType")]
9721    pub display_type: ClickStackPieRawSqlChartConfigDisplaytype,
9722    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9723    pub number_format: Option<ClickStackNumberFormat>,
9724    #[serde(rename = "sourceId", skip_serializing_if = "Option::is_none", default)]
9725    pub source_id: Option<String>,
9726    #[serde(rename = "sqlTemplate")]
9727    pub sql_template: String,
9728}
9729
9730/// `ClickStackQuerySetting` from the ClickHouse Cloud API.
9731#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9732pub struct ClickStackQuerySetting {
9733    pub setting: String,
9734    pub value: String,
9735}
9736
9737/// `ClickStackSavedFilterValue` from the ClickHouse Cloud API.
9738#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9739pub struct ClickStackSavedFilterValue {
9740    pub condition: String,
9741    #[serde(skip_serializing_if = "Option::is_none", default)]
9742    pub r#type: Option<ClickStackSavedFilterValueType>,
9743}
9744
9745/// `ClickStackSearchChartConfig` from the ClickHouse Cloud API.
9746#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9747pub struct ClickStackSearchChartConfig {
9748    #[serde(rename = "displayType")]
9749    pub display_type: ClickStackSearchChartConfigDisplaytype,
9750    pub select: String,
9751    #[serde(rename = "sourceId")]
9752    pub source_id: String,
9753    #[serde(skip_serializing_if = "Option::is_none", default)]
9754    pub r#where: Option<String>,
9755    #[serde(rename = "whereLanguage")]
9756    pub where_language: ClickStackSearchChartConfigWherelanguage,
9757}
9758
9759/// `ClickStackSearchChartSeries` from the ClickHouse Cloud API.
9760#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9761pub struct ClickStackSearchChartSeries {
9762    pub fields: Vec<String>,
9763    #[serde(rename = "sourceId")]
9764    pub source_id: String,
9765    pub r#type: ClickStackSearchChartSeriesType,
9766    pub r#where: String,
9767    #[serde(rename = "whereLanguage")]
9768    pub where_language: ClickStackSearchChartSeriesWherelanguage,
9769}
9770
9771/// `ClickStackSelectItem` from the ClickHouse Cloud API.
9772#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9773pub struct ClickStackSelectItem {
9774    #[serde(rename = "aggFn")]
9775    pub agg_fn: ClickStackSelectItemAggfn,
9776    #[serde(skip_serializing_if = "Option::is_none", default)]
9777    pub alias: Option<String>,
9778    #[serde(skip_serializing_if = "Option::is_none", default)]
9779    pub level: Option<ClickStackSelectItemLevel>,
9780    #[serde(rename = "metricName", skip_serializing_if = "Option::is_none", default)]
9781    pub metric_name: Option<String>,
9782    #[serde(rename = "metricType", skip_serializing_if = "Option::is_none", default)]
9783    pub metric_type: Option<ClickStackSelectItemMetrictype>,
9784    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9785    pub number_format: Option<ClickStackNumberFormat>,
9786    #[serde(rename = "periodAggFn", skip_serializing_if = "Option::is_none", default)]
9787    pub period_agg_fn: Option<ClickStackSelectItemPeriodaggfn>,
9788    #[serde(rename = "valueExpression", skip_serializing_if = "Option::is_none", default)]
9789    pub value_expression: Option<String>,
9790    #[serde(skip_serializing_if = "Option::is_none", default)]
9791    pub r#where: Option<String>,
9792    #[serde(rename = "whereLanguage", skip_serializing_if = "Option::is_none", default)]
9793    pub where_language: Option<ClickStackSelectItemWherelanguage>,
9794}
9795
9796/// `ClickStackSessionSource` from the ClickHouse Cloud API.
9797#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9798pub struct ClickStackSessionSource {
9799    pub connection: String,
9800    pub from: ClickStackSourceFrom,
9801    pub id: String,
9802    pub kind: ClickStackSessionSourceKind,
9803    pub name: String,
9804    #[serde(rename = "querySettings", skip_serializing_if = "Option::is_none", default)]
9805    pub query_settings: Option<Vec<ClickStackQuerySetting>>,
9806    #[serde(rename = "timestampValueExpression", skip_serializing_if = "Option::is_none", default)]
9807    pub timestamp_value_expression: Option<String>,
9808    #[serde(rename = "traceSourceId")]
9809    pub trace_source_id: String,
9810}
9811
9812/// `ClickStackSlackAPIWebhook` from the ClickHouse Cloud API.
9813#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9814pub struct ClickStackSlackAPIWebhook {
9815    #[serde(rename = "createdAt")]
9816    pub created_at: chrono::DateTime<chrono::Utc>,
9817    #[serde(skip_serializing_if = "Option::is_none", default)]
9818    pub description: Option<String>,
9819    pub id: String,
9820    pub name: String,
9821    pub service: ClickStackSlackAPIWebhookService,
9822    #[serde(rename = "updatedAt")]
9823    pub updated_at: chrono::DateTime<chrono::Utc>,
9824    #[serde(skip_serializing_if = "Option::is_none", default)]
9825    pub url: Option<String>,
9826}
9827
9828/// `ClickStackSlackWebhook` from the ClickHouse Cloud API.
9829#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9830pub struct ClickStackSlackWebhook {
9831    #[serde(rename = "createdAt")]
9832    pub created_at: chrono::DateTime<chrono::Utc>,
9833    #[serde(skip_serializing_if = "Option::is_none", default)]
9834    pub description: Option<String>,
9835    pub id: String,
9836    pub name: String,
9837    pub service: ClickStackSlackWebhookService,
9838    #[serde(rename = "updatedAt")]
9839    pub updated_at: chrono::DateTime<chrono::Utc>,
9840    #[serde(skip_serializing_if = "Option::is_none", default)]
9841    pub url: Option<String>,
9842}
9843
9844/// `ClickStackSourceFilterSettings` from the ClickHouse Cloud API.
9845#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9846pub struct ClickStackSourceFilterSettings {
9847    pub columns: Vec<ClickStackFilterSettingsColumn>,
9848    #[serde(rename = "databaseName")]
9849    pub database_name: String,
9850    #[serde(rename = "tableName")]
9851    pub table_name: String,
9852}
9853
9854/// `ClickStackSourceFrom` from the ClickHouse Cloud API.
9855#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9856pub struct ClickStackSourceFrom {
9857    #[serde(rename = "databaseName")]
9858    pub database_name: String,
9859    #[serde(rename = "tableName")]
9860    pub table_name: String,
9861}
9862
9863/// `ClickStackTableBuilderChartConfig` from the ClickHouse Cloud API.
9864#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9865pub struct ClickStackTableBuilderChartConfig {
9866    #[serde(rename = "asRatio", skip_serializing_if = "Option::is_none", default)]
9867    pub as_ratio: Option<bool>,
9868    #[serde(rename = "displayType")]
9869    pub display_type: ClickStackTableBuilderChartConfigDisplaytype,
9870    #[serde(rename = "groupBy", skip_serializing_if = "Option::is_none", default)]
9871    pub group_by: Option<String>,
9872    #[serde(rename = "groupByColumnsOnLeft", skip_serializing_if = "Option::is_none", default)]
9873    pub group_by_columns_on_left: Option<bool>,
9874    #[serde(skip_serializing_if = "Option::is_none", default)]
9875    pub having: Option<String>,
9876    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9877    pub number_format: Option<ClickStackNumberFormat>,
9878    #[serde(rename = "onClick", skip_serializing_if = "Option::is_none", default)]
9879    pub on_click: Option<ClickStackOnClick>,
9880    #[serde(rename = "orderBy", skip_serializing_if = "Option::is_none", default)]
9881    pub order_by: Option<String>,
9882    pub select: Vec<ClickStackSelectItem>,
9883    #[serde(rename = "sourceId")]
9884    pub source_id: String,
9885}
9886
9887/// `ClickStackTableChartSeries` from the ClickHouse Cloud API.
9888#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9889pub struct ClickStackTableChartSeries {
9890    #[serde(rename = "aggFn")]
9891    pub agg_fn: ClickStackTableChartSeriesAggfn,
9892    #[serde(skip_serializing_if = "Option::is_none", default)]
9893    pub alias: Option<String>,
9894    #[serde(skip_serializing_if = "Option::is_none", default)]
9895    pub field: Option<String>,
9896    #[serde(rename = "groupBy")]
9897    pub group_by: Vec<String>,
9898    #[serde(skip_serializing_if = "Option::is_none", default)]
9899    pub level: Option<f64>,
9900    #[serde(rename = "metricDataType", skip_serializing_if = "Option::is_none", default)]
9901    pub metric_data_type: Option<ClickStackTableChartSeriesMetricdatatype>,
9902    #[serde(rename = "metricName", skip_serializing_if = "Option::is_none", default)]
9903    pub metric_name: Option<String>,
9904    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9905    pub number_format: Option<ClickStackNumberFormat>,
9906    #[serde(rename = "sortOrder", skip_serializing_if = "Option::is_none", default)]
9907    pub sort_order: Option<ClickStackTableChartSeriesSortorder>,
9908    #[serde(rename = "sourceId")]
9909    pub source_id: String,
9910    pub r#type: ClickStackTableChartSeriesType,
9911    pub r#where: String,
9912    #[serde(rename = "whereLanguage")]
9913    pub where_language: ClickStackTableChartSeriesWherelanguage,
9914}
9915
9916/// `ClickStackTableRawSqlChartConfig` from the ClickHouse Cloud API.
9917#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9918pub struct ClickStackTableRawSqlChartConfig {
9919    #[serde(rename = "configType")]
9920    pub config_type: ClickStackTableRawSqlChartConfigConfigtype,
9921    #[serde(rename = "connectionId")]
9922    pub connection_id: String,
9923    #[serde(rename = "displayType")]
9924    pub display_type: ClickStackTableRawSqlChartConfigDisplaytype,
9925    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9926    pub number_format: Option<ClickStackNumberFormat>,
9927    #[serde(rename = "onClick", skip_serializing_if = "Option::is_none", default)]
9928    pub on_click: Option<ClickStackOnClick>,
9929    #[serde(rename = "sourceId", skip_serializing_if = "Option::is_none", default)]
9930    pub source_id: Option<String>,
9931    #[serde(rename = "sqlTemplate")]
9932    pub sql_template: String,
9933}
9934
9935/// `ClickStackTileInput` from the ClickHouse Cloud API.
9936#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9937pub struct ClickStackTileInput {
9938    #[cfg(feature = "deprecated-fields")]
9939    #[serde(rename = "asRatio", skip_serializing_if = "Option::is_none", default)]
9940    pub as_ratio: Option<bool>,
9941    #[serde(skip_serializing_if = "Option::is_none", default)]
9942    pub config: Option<ClickStackTileConfig>,
9943    #[serde(rename = "containerId", skip_serializing_if = "Option::is_none", default)]
9944    pub container_id: Option<String>,
9945    pub h: i64,
9946    #[serde(skip_serializing_if = "Option::is_none", default)]
9947    pub id: Option<String>,
9948    pub name: String,
9949    #[cfg(feature = "deprecated-fields")]
9950    #[serde(skip_serializing_if = "Option::is_none", default)]
9951    pub series: Option<Vec<ClickStackDashboardChartSeries>>,
9952    #[serde(rename = "tabId", skip_serializing_if = "Option::is_none", default)]
9953    pub tab_id: Option<String>,
9954    pub w: i64,
9955    pub x: i64,
9956    pub y: i64,
9957}
9958
9959/// `ClickStackTileOutput` from the ClickHouse Cloud API.
9960#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9961pub struct ClickStackTileOutput {
9962    #[serde(skip_serializing_if = "Option::is_none", default)]
9963    pub config: Option<ClickStackTileConfig>,
9964    #[serde(rename = "containerId", skip_serializing_if = "Option::is_none", default)]
9965    pub container_id: Option<String>,
9966    pub h: i64,
9967    pub id: String,
9968    pub name: String,
9969    #[serde(rename = "tabId", skip_serializing_if = "Option::is_none", default)]
9970    pub tab_id: Option<String>,
9971    pub w: i64,
9972    pub x: i64,
9973    pub y: i64,
9974}
9975
9976/// `ClickStackTimeChartSeries` from the ClickHouse Cloud API.
9977#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
9978pub struct ClickStackTimeChartSeries {
9979    #[serde(rename = "aggFn")]
9980    pub agg_fn: ClickStackTimeChartSeriesAggfn,
9981    #[serde(skip_serializing_if = "Option::is_none", default)]
9982    pub alias: Option<String>,
9983    #[serde(rename = "displayType", skip_serializing_if = "Option::is_none", default)]
9984    pub display_type: Option<ClickStackTimeChartSeriesDisplaytype>,
9985    #[serde(skip_serializing_if = "Option::is_none", default)]
9986    pub field: Option<String>,
9987    #[serde(rename = "groupBy")]
9988    pub group_by: Vec<String>,
9989    #[serde(skip_serializing_if = "Option::is_none", default)]
9990    pub level: Option<f64>,
9991    #[serde(rename = "metricDataType", skip_serializing_if = "Option::is_none", default)]
9992    pub metric_data_type: Option<ClickStackTimeChartSeriesMetricdatatype>,
9993    #[serde(rename = "metricName", skip_serializing_if = "Option::is_none", default)]
9994    pub metric_name: Option<String>,
9995    #[serde(rename = "numberFormat", skip_serializing_if = "Option::is_none", default)]
9996    pub number_format: Option<ClickStackNumberFormat>,
9997    #[serde(rename = "sourceId")]
9998    pub source_id: String,
9999    pub r#type: ClickStackTimeChartSeriesType,
10000    pub r#where: String,
10001    #[serde(rename = "whereLanguage")]
10002    pub where_language: ClickStackTimeChartSeriesWherelanguage,
10003}
10004
10005/// `ClickStackTraceSource` from the ClickHouse Cloud API.
10006#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10007pub struct ClickStackTraceSource {
10008    pub connection: String,
10009    #[serde(rename = "defaultTableSelectExpression", skip_serializing_if = "Option::is_none", default)]
10010    pub default_table_select_expression: Option<String>,
10011    #[serde(rename = "durationExpression")]
10012    pub duration_expression: String,
10013    #[serde(rename = "durationPrecision")]
10014    pub duration_precision: i64,
10015    #[serde(rename = "eventAttributesExpression", skip_serializing_if = "Option::is_none", default)]
10016    pub event_attributes_expression: Option<String>,
10017    #[serde(rename = "filterSettings", skip_serializing_if = "Option::is_none", default)]
10018    pub filter_settings: Option<ClickStackSourceFilterSettings>,
10019    pub from: ClickStackSourceFrom,
10020    #[serde(rename = "highlightedRowAttributeExpressions", skip_serializing_if = "Option::is_none", default)]
10021    pub highlighted_row_attribute_expressions: Option<Vec<ClickStackHighlightedAttributeExpression>>,
10022    #[serde(rename = "highlightedTraceAttributeExpressions", skip_serializing_if = "Option::is_none", default)]
10023    pub highlighted_trace_attribute_expressions: Option<Vec<ClickStackHighlightedAttributeExpression>>,
10024    pub id: String,
10025    #[serde(rename = "implicitColumnExpression", skip_serializing_if = "Option::is_none", default)]
10026    pub implicit_column_expression: Option<String>,
10027    pub kind: ClickStackTraceSourceKind,
10028    #[serde(rename = "logSourceId", skip_serializing_if = "Option::is_none", default)]
10029    pub log_source_id: Option<String>,
10030    #[serde(rename = "materializedViews", skip_serializing_if = "Option::is_none", default)]
10031    pub materialized_views: Option<Vec<ClickStackMaterializedView>>,
10032    #[serde(rename = "metadataMaterializedViews", skip_serializing_if = "Option::is_none", default)]
10033    pub metadata_materialized_views: Option<ClickStackTraceSourceMetadataMaterializedViews>,
10034    #[serde(rename = "metricSourceId", skip_serializing_if = "Option::is_none", default)]
10035    pub metric_source_id: Option<String>,
10036    pub name: String,
10037    #[serde(rename = "parentSpanIdExpression")]
10038    pub parent_span_id_expression: String,
10039    #[serde(rename = "querySettings", skip_serializing_if = "Option::is_none", default)]
10040    pub query_settings: Option<Vec<ClickStackQuerySetting>>,
10041    #[serde(rename = "resourceAttributesExpression", skip_serializing_if = "Option::is_none", default)]
10042    pub resource_attributes_expression: Option<String>,
10043    #[serde(rename = "serviceNameExpression", skip_serializing_if = "Option::is_none", default)]
10044    pub service_name_expression: Option<String>,
10045    #[serde(rename = "sessionSourceId", skip_serializing_if = "Option::is_none", default)]
10046    pub session_source_id: Option<String>,
10047    #[serde(rename = "spanEventsValueExpression", skip_serializing_if = "Option::is_none", default)]
10048    pub span_events_value_expression: Option<String>,
10049    #[serde(rename = "spanIdExpression")]
10050    pub span_id_expression: String,
10051    #[serde(rename = "spanKindExpression")]
10052    pub span_kind_expression: String,
10053    #[serde(rename = "spanNameExpression")]
10054    pub span_name_expression: String,
10055    #[serde(rename = "statusCodeExpression", skip_serializing_if = "Option::is_none", default)]
10056    pub status_code_expression: Option<String>,
10057    #[serde(rename = "statusMessageExpression", skip_serializing_if = "Option::is_none", default)]
10058    pub status_message_expression: Option<String>,
10059    #[serde(rename = "timestampValueExpression")]
10060    pub timestamp_value_expression: String,
10061    #[serde(rename = "traceIdExpression")]
10062    pub trace_id_expression: String,
10063}
10064
10065/// `ClickStackTraceSourceMetadataMaterializedViews` from the ClickHouse Cloud API.
10066#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10067pub struct ClickStackTraceSourceMetadataMaterializedViews {
10068    #[serde(default)]
10069    pub granularity: String,
10070    #[serde(rename = "keyRollupTable", default)]
10071    pub key_rollup_table: String,
10072    #[serde(rename = "kvRollupTable", default)]
10073    pub kv_rollup_table: String,
10074}
10075
10076/// `ClickStackUpdateAlertRequest` from the ClickHouse Cloud API.
10077#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10078pub struct ClickStackUpdateAlertRequest {
10079    #[serde(default)]
10080    pub channel: ClickStackAlertChannel,
10081    #[serde(rename = "dashboardId", skip_serializing_if = "Option::is_none", default)]
10082    pub dashboard_id: Option<String>,
10083    #[serde(rename = "groupBy", skip_serializing_if = "Option::is_none", default)]
10084    pub group_by: Option<String>,
10085    #[serde(default)]
10086    pub interval: ClickStackUpdateAlertRequestInterval,
10087    #[serde(skip_serializing_if = "Option::is_none", default)]
10088    pub message: Option<String>,
10089    #[serde(skip_serializing_if = "Option::is_none", default)]
10090    pub name: Option<String>,
10091    #[serde(skip_serializing_if = "Option::is_none", default)]
10092    pub note: Option<String>,
10093    #[serde(rename = "savedSearchId", skip_serializing_if = "Option::is_none", default)]
10094    pub saved_search_id: Option<String>,
10095    #[serde(rename = "scheduleOffsetMinutes", skip_serializing_if = "Option::is_none", default)]
10096    pub schedule_offset_minutes: Option<i64>,
10097    #[serde(rename = "scheduleStartAt", skip_serializing_if = "Option::is_none", default)]
10098    pub schedule_start_at: Option<chrono::DateTime<chrono::Utc>>,
10099    #[serde(default)]
10100    pub source: ClickStackUpdateAlertRequestSource,
10101    #[serde(default)]
10102    pub threshold: f64,
10103    #[serde(rename = "thresholdMax", skip_serializing_if = "Option::is_none", default)]
10104    pub threshold_max: Option<f64>,
10105    #[serde(rename = "thresholdType", default)]
10106    pub threshold_type: ClickStackUpdateAlertRequestThresholdtype,
10107    #[serde(rename = "tileId", skip_serializing_if = "Option::is_none", default)]
10108    pub tile_id: Option<String>,
10109}
10110
10111/// `ClickStackUpdateDashboardRequest` from the ClickHouse Cloud API.
10112#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10113pub struct ClickStackUpdateDashboardRequest {
10114    #[serde(skip_serializing_if = "Option::is_none", default)]
10115    pub containers: Option<Vec<ClickStackDashboardContainer>>,
10116    #[serde(skip_serializing_if = "Option::is_none", default)]
10117    pub filters: Option<Vec<ClickStackFilter>>,
10118    pub name: String,
10119    #[serde(rename = "savedFilterValues", skip_serializing_if = "Option::is_none", default)]
10120    pub saved_filter_values: Option<Vec<ClickStackSavedFilterValue>>,
10121    #[serde(rename = "savedQuery", skip_serializing_if = "Option::is_none", default)]
10122    pub saved_query: Option<String>,
10123    #[serde(rename = "savedQueryLanguage", skip_serializing_if = "Option::is_none", default)]
10124    pub saved_query_language: Option<ClickStackUpdateDashboardRequestSavedquerylanguage>,
10125    #[serde(skip_serializing_if = "Option::is_none", default)]
10126    pub tags: Option<Vec<String>>,
10127    pub tiles: Vec<ClickStackTileInput>,
10128}
10129
10130/// `CreateReversePrivateEndpoint` from the ClickHouse Cloud API.
10131#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10132pub struct CreateReversePrivateEndpoint {
10133    #[serde(rename = "customPrivateDnsMappings", skip_serializing_if = "Option::is_none", default)]
10134    pub custom_private_dns_mappings: Option<Vec<CustomPrivateDnsMapping>>,
10135    #[serde(default)]
10136    pub description: String,
10137    #[serde(rename = "gcpServiceAttachment", skip_serializing_if = "Option::is_none", default)]
10138    pub gcp_service_attachment: Option<String>,
10139    #[serde(rename = "mskAuthentication", skip_serializing_if = "Option::is_none", default)]
10140    pub msk_authentication: Option<CreateReversePrivateEndpointMskauthentication>,
10141    #[serde(rename = "mskClusterArn", skip_serializing_if = "Option::is_none", default)]
10142    pub msk_cluster_arn: Option<String>,
10143    #[serde(default)]
10144    pub r#type: CreateReversePrivateEndpointType,
10145    #[serde(rename = "vpcEndpointServiceName", skip_serializing_if = "Option::is_none", default)]
10146    pub vpc_endpoint_service_name: Option<String>,
10147    #[serde(rename = "vpcResourceConfigurationId", skip_serializing_if = "Option::is_none", default)]
10148    pub vpc_resource_configuration_id: Option<String>,
10149    #[serde(rename = "vpcResourceShareArn", skip_serializing_if = "Option::is_none", default)]
10150    pub vpc_resource_share_arn: Option<String>,
10151}
10152
10153/// `CurrentScaling` from the ClickHouse Cloud API.
10154#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10155pub struct CurrentScaling {
10156    #[serde(rename = "activeEntryId", default)]
10157    pub active_entry_id: uuid::Uuid,
10158    #[serde(rename = "effectiveAutoscalingMode", default)]
10159    pub effective_autoscaling_mode: CurrentScalingEffectiveautoscalingmode,
10160    #[serde(rename = "effectiveIdleScaling", default)]
10161    pub effective_idle_scaling: bool,
10162    #[serde(rename = "effectiveIdleTimeoutMinutes", default)]
10163    pub effective_idle_timeout_minutes: i64,
10164    #[serde(rename = "effectiveMaxReplicaMemoryGb", default)]
10165    pub effective_max_replica_memory_gb: f64,
10166    #[serde(rename = "effectiveMaxReplicas", default)]
10167    pub effective_max_replicas: i64,
10168    #[serde(rename = "effectiveMinReplicaMemoryGb", default)]
10169    pub effective_min_replica_memory_gb: f64,
10170    #[serde(rename = "effectiveMinReplicas", default)]
10171    pub effective_min_replicas: i64,
10172}
10173
10174/// `CustomPrivateDnsMapping` from the ClickHouse Cloud API.
10175#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10176pub struct CustomPrivateDnsMapping {
10177    #[serde(rename = "privateDnsName", skip_serializing_if = "Option::is_none", default)]
10178    pub private_dns_name: Option<String>,
10179}
10180
10181/// `GcpBackupBucket` from the ClickHouse Cloud API.
10182#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10183pub struct GcpBackupBucket {
10184    #[serde(rename = "accessKeyId", default)]
10185    pub access_key_id: String,
10186    #[serde(rename = "bucketPath", default)]
10187    pub bucket_path: String,
10188    #[serde(rename = "bucketProvider", default)]
10189    pub bucket_provider: GcpBackupBucketBucketprovider,
10190    #[serde(default)]
10191    pub id: uuid::Uuid,
10192}
10193
10194/// `GcpBackupBucketPatchRequestV1` from the ClickHouse Cloud API.
10195#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10196pub struct GcpBackupBucketPatchRequestV1 {
10197    #[serde(rename = "accessKeyId", default)]
10198    pub access_key_id: String,
10199    #[serde(rename = "bucketPath", default)]
10200    pub bucket_path: String,
10201    #[serde(rename = "bucketProvider", default)]
10202    pub bucket_provider: GcpBackupBucketPatchRequestV1Bucketprovider,
10203    #[serde(rename = "secretAccessKey", default)]
10204    pub secret_access_key: String,
10205}
10206
10207/// `GcpBackupBucketPostRequestV1` from the ClickHouse Cloud API.
10208#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10209pub struct GcpBackupBucketPostRequestV1 {
10210    #[serde(rename = "accessKeyId", default)]
10211    pub access_key_id: String,
10212    #[serde(rename = "bucketPath", default)]
10213    pub bucket_path: String,
10214    #[serde(rename = "bucketProvider", default)]
10215    pub bucket_provider: GcpBackupBucketPostRequestV1Bucketprovider,
10216    #[serde(rename = "secretAccessKey", default)]
10217    pub secret_access_key: String,
10218}
10219
10220/// `GcpBackupBucketProperties` from the ClickHouse Cloud API.
10221#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10222pub struct GcpBackupBucketProperties {
10223    #[serde(rename = "accessKeyId", default)]
10224    pub access_key_id: String,
10225    #[serde(rename = "bucketPath", default)]
10226    pub bucket_path: String,
10227    #[serde(rename = "bucketProvider", default)]
10228    pub bucket_provider: GcpBackupBucketPropertiesBucketprovider,
10229}
10230
10231/// `InstancePrivateEndpoint` from the ClickHouse Cloud API.
10232#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10233pub struct InstancePrivateEndpoint {
10234    #[serde(rename = "cloudProvider", default)]
10235    pub cloud_provider: InstancePrivateEndpointCloudprovider,
10236    #[serde(default)]
10237    pub description: String,
10238    #[serde(default)]
10239    pub id: String,
10240    #[serde(default)]
10241    pub region: InstancePrivateEndpointRegion,
10242}
10243
10244/// `InstancePrivateEndpointsPatch` from the ClickHouse Cloud API.
10245#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10246pub struct InstancePrivateEndpointsPatch {
10247    #[serde(default)]
10248    pub add: Vec<String>,
10249    #[serde(default)]
10250    pub remove: Vec<String>,
10251}
10252
10253/// `InstanceServiceQueryApiEndpointsPostRequest` from the ClickHouse Cloud API.
10254#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10255pub struct InstanceServiceQueryApiEndpointsPostRequest {
10256    #[serde(rename = "allowedOrigins", default)]
10257    pub allowed_origins: String,
10258    #[serde(rename = "openApiKeys", default)]
10259    pub open_api_keys: Vec<String>,
10260    #[serde(default)]
10261    pub roles: Vec<String>,
10262}
10263
10264/// `InstanceTagsPatch` from the ClickHouse Cloud API.
10265#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10266pub struct InstanceTagsPatch {
10267    #[serde(default)]
10268    pub add: Vec<ResourceTagsV1>,
10269    #[serde(default)]
10270    pub remove: Vec<ResourceTagsV1>,
10271}
10272
10273/// `Invitation` from the ClickHouse Cloud API.
10274#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10275pub struct Invitation {
10276    #[serde(rename = "assignedRoles", default)]
10277    pub assigned_roles: Vec<AssignedRole>,
10278    #[serde(rename = "createdAt", default)]
10279    pub created_at: chrono::DateTime<chrono::Utc>,
10280    #[serde(default)]
10281    pub email: String,
10282    #[serde(rename = "expireAt", default)]
10283    pub expire_at: chrono::DateTime<chrono::Utc>,
10284    #[serde(default)]
10285    pub id: uuid::Uuid,
10286    #[cfg(feature = "deprecated-fields")]
10287    #[serde(default)]
10288    pub role: InvitationRole,
10289}
10290
10291/// `InvitationPostRequest` from the ClickHouse Cloud API.
10292#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10293pub struct InvitationPostRequest {
10294    #[serde(rename = "assignedRoleIds", default)]
10295    pub assigned_role_ids: Vec<String>,
10296    #[serde(default)]
10297    pub email: String,
10298    #[cfg(feature = "deprecated-fields")]
10299    #[serde(skip_serializing_if = "Option::is_none", default)]
10300    pub role: Option<InvitationPostRequestRole>,
10301}
10302
10303/// `IpAccessListEntry` from the ClickHouse Cloud API.
10304#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10305pub struct IpAccessListEntry {
10306    #[serde(skip_serializing_if = "Option::is_none", default)]
10307    pub description: Option<String>,
10308    #[serde(default)]
10309    pub source: String,
10310}
10311
10312/// `IpAccessListPatch` from the ClickHouse Cloud API.
10313#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10314pub struct IpAccessListPatch {
10315    #[serde(default)]
10316    pub add: Vec<IpAccessListEntry>,
10317    #[serde(default)]
10318    pub remove: Vec<IpAccessListEntry>,
10319}
10320
10321/// `Member` from the ClickHouse Cloud API.
10322#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10323pub struct Member {
10324    #[serde(rename = "assignedRoles", default)]
10325    pub assigned_roles: Vec<AssignedRole>,
10326    #[serde(default)]
10327    pub email: String,
10328    #[serde(rename = "joinedAt", default)]
10329    pub joined_at: chrono::DateTime<chrono::Utc>,
10330    #[serde(default)]
10331    pub name: String,
10332    #[cfg(feature = "deprecated-fields")]
10333    #[serde(default)]
10334    pub role: MemberRole,
10335    #[serde(rename = "userId", default)]
10336    pub user_id: String,
10337}
10338
10339/// `MemberPatchRequest` from the ClickHouse Cloud API.
10340#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10341pub struct MemberPatchRequest {
10342    #[serde(rename = "assignedRoleIds", skip_serializing_if = "Option::is_none", default)]
10343    pub assigned_role_ids: Option<Vec<String>>,
10344    #[cfg(feature = "deprecated-fields")]
10345    #[serde(skip_serializing_if = "Option::is_none", default)]
10346    pub role: Option<MemberPatchRequestRole>,
10347}
10348
10349/// `MskIamUser` from the ClickHouse Cloud API.
10350#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10351pub struct MskIamUser {
10352    #[serde(rename = "accessKeyId", default)]
10353    pub access_key_id: String,
10354    #[serde(rename = "secretKey", default)]
10355    pub secret_key: String,
10356}
10357
10358/// `MutualTLS` from the ClickHouse Cloud API.
10359#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10360pub struct MutualTLS {
10361    #[serde(default)]
10362    pub certificate: String,
10363    #[serde(rename = "privateKey", default)]
10364    pub private_key: String,
10365}
10366
10367/// `Organization` from the ClickHouse Cloud API.
10368#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10369pub struct Organization {
10370    #[serde(rename = "byocConfig", default)]
10371    pub byoc_config: Vec<ByocConfig>,
10372    #[serde(rename = "createdAt", default)]
10373    pub created_at: chrono::DateTime<chrono::Utc>,
10374    #[serde(rename = "enableCoreDumps", default)]
10375    pub enable_core_dumps: bool,
10376    #[serde(default)]
10377    pub id: uuid::Uuid,
10378    #[serde(default)]
10379    pub name: String,
10380    #[serde(rename = "privateEndpoints", default)]
10381    pub private_endpoints: Vec<OrganizationPrivateEndpoint>,
10382}
10383
10384/// `OrganizationCloudRegionPrivateEndpointConfig` from the ClickHouse Cloud API.
10385#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10386pub struct OrganizationCloudRegionPrivateEndpointConfig {
10387    #[serde(rename = "endpointServiceId", default)]
10388    pub endpoint_service_id: String,
10389}
10390
10391/// `OrganizationPatchPrivateEndpoint` from the ClickHouse Cloud API.
10392#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10393pub struct OrganizationPatchPrivateEndpoint {
10394    #[serde(rename = "cloudProvider", default)]
10395    pub cloud_provider: OrganizationPatchPrivateEndpointCloudprovider,
10396    #[serde(skip_serializing_if = "Option::is_none", default)]
10397    pub description: Option<String>,
10398    #[serde(default)]
10399    pub id: String,
10400    #[serde(default)]
10401    pub region: OrganizationPatchPrivateEndpointRegion,
10402}
10403
10404/// `OrganizationPatchRequest` from the ClickHouse Cloud API.
10405#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10406pub struct OrganizationPatchRequest {
10407    #[serde(rename = "enableCoreDumps", skip_serializing_if = "Option::is_none", default)]
10408    pub enable_core_dumps: Option<bool>,
10409    #[serde(skip_serializing_if = "Option::is_none", default)]
10410    pub name: Option<String>,
10411    #[serde(rename = "privateEndpoints", skip_serializing_if = "Option::is_none", default)]
10412    pub private_endpoints: Option<OrganizationPrivateEndpointsPatch>,
10413}
10414
10415/// `OrganizationPrivateEndpoint` from the ClickHouse Cloud API.
10416#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10417pub struct OrganizationPrivateEndpoint {
10418    #[serde(rename = "cloudProvider", default)]
10419    pub cloud_provider: OrganizationPrivateEndpointCloudprovider,
10420    #[serde(default)]
10421    pub description: String,
10422    #[serde(default)]
10423    pub id: String,
10424    #[serde(default)]
10425    pub region: OrganizationPrivateEndpointRegion,
10426}
10427
10428/// `OrganizationPrivateEndpointsPatch` from the ClickHouse Cloud API.
10429#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10430pub struct OrganizationPrivateEndpointsPatch {
10431    #[cfg(feature = "deprecated-fields")]
10432    #[serde(skip_serializing_if = "Option::is_none", default)]
10433    pub add: Option<Vec<OrganizationPatchPrivateEndpoint>>,
10434    #[serde(default)]
10435    pub remove: Vec<OrganizationPatchPrivateEndpoint>,
10436}
10437
10438/// `PLAIN` from the ClickHouse Cloud API.
10439#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10440pub struct PLAIN {
10441    #[serde(default)]
10442    pub password: String,
10443    #[serde(default)]
10444    pub username: String,
10445}
10446
10447/// `PostgresService` from the ClickHouse Cloud API.
10448#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10449pub struct PostgresService {
10450    #[serde(rename = "connectionString", default)]
10451    pub connection_string: String,
10452    #[serde(rename = "createdAt", default)]
10453    pub created_at: PgCreatedAtProperty,
10454    #[serde(rename = "haType", default)]
10455    pub ha_type: PgHaType,
10456    #[serde(default)]
10457    pub hostname: String,
10458    #[serde(default)]
10459    pub id: PgIdProperty,
10460    #[serde(rename = "isPrimary", default)]
10461    pub is_primary: PgIsPrimaryProperty,
10462    #[serde(default)]
10463    pub name: PgNameProperty,
10464    #[serde(default)]
10465    pub password: String,
10466    #[serde(rename = "postgresVersion", default)]
10467    pub postgres_version: PgVersion,
10468    #[serde(default)]
10469    pub provider: PgProvider,
10470    #[serde(default)]
10471    pub region: PgRegion,
10472    #[serde(default)]
10473    pub size: PgSize,
10474    #[serde(default)]
10475    pub state: PgStateProperty,
10476    #[serde(rename = "storageSize", default)]
10477    pub storage_size: PgStorageSize,
10478    #[serde(default)]
10479    pub tags: PgTags,
10480    #[serde(default)]
10481    pub username: String,
10482}
10483
10484/// `PostgresServiceListItem` from the ClickHouse Cloud API.
10485#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10486pub struct PostgresServiceListItem {
10487    #[serde(rename = "createdAt", default)]
10488    pub created_at: PgCreatedAtProperty,
10489    #[serde(rename = "haType", default)]
10490    pub ha_type: PgHaType,
10491    #[serde(default)]
10492    pub id: PgIdProperty,
10493    #[serde(rename = "isPrimary", default)]
10494    pub is_primary: PgIsPrimaryProperty,
10495    #[serde(default)]
10496    pub name: PgNameProperty,
10497    #[serde(rename = "postgresVersion", default)]
10498    pub postgres_version: PgVersion,
10499    #[serde(default)]
10500    pub provider: PgProvider,
10501    #[serde(default)]
10502    pub region: PgRegion,
10503    #[serde(default)]
10504    pub size: PgSize,
10505    #[serde(default)]
10506    pub state: PgStateProperty,
10507    #[serde(default)]
10508    pub tags: PgTags,
10509}
10510
10511/// `PostgresServicePasswordResource` from the ClickHouse Cloud API.
10512#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10513pub struct PostgresServicePasswordResource {
10514    #[serde(default)]
10515    pub password: String,
10516}
10517
10518/// `PostgresServicePatchRequest` from the ClickHouse Cloud API.
10519#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10520pub struct PostgresServicePatchRequest {
10521    #[serde(rename = "haType", skip_serializing_if = "Option::is_none", default)]
10522    pub ha_type: Option<PgHaType>,
10523    #[serde(skip_serializing_if = "Option::is_none", default)]
10524    pub size: Option<PgSize>,
10525    #[serde(skip_serializing_if = "Option::is_none", default)]
10526    pub tags: Option<PgTags>,
10527}
10528
10529/// `PostgresServicePostRequest` from the ClickHouse Cloud API.
10530#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10531pub struct PostgresServicePostRequest {
10532    #[serde(rename = "haType", skip_serializing_if = "Option::is_none", default)]
10533    pub ha_type: Option<PgHaType>,
10534    pub name: PgNameProperty,
10535    #[serde(rename = "pgBouncerConfig", skip_serializing_if = "Option::is_none", default)]
10536    pub pg_bouncer_config: Option<PgBouncerConfig>,
10537    #[serde(rename = "pgConfig", skip_serializing_if = "Option::is_none", default)]
10538    pub pg_config: Option<PgConfig>,
10539    #[serde(rename = "postgresVersion", skip_serializing_if = "Option::is_none", default)]
10540    pub postgres_version: Option<PgVersion>,
10541    pub provider: PgProvider,
10542    pub region: PgRegion,
10543    pub size: PgSize,
10544    #[serde(skip_serializing_if = "Option::is_none", default)]
10545    pub tags: Option<PgTags>,
10546}
10547
10548/// `PostgresServiceReadReplicaRequest` from the ClickHouse Cloud API.
10549#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10550pub struct PostgresServiceReadReplicaRequest {
10551    pub name: PgNameProperty,
10552    #[serde(rename = "pgBouncerConfig", skip_serializing_if = "Option::is_none", default)]
10553    pub pg_bouncer_config: Option<PgBouncerConfig>,
10554    #[serde(rename = "pgConfig", skip_serializing_if = "Option::is_none", default)]
10555    pub pg_config: Option<PgConfig>,
10556    #[serde(skip_serializing_if = "Option::is_none", default)]
10557    pub tags: Option<PgTags>,
10558}
10559
10560/// `PostgresServiceRestoreRequest` from the ClickHouse Cloud API.
10561#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10562pub struct PostgresServiceRestoreRequest {
10563    pub name: PgNameProperty,
10564    #[serde(rename = "pgBouncerConfig", skip_serializing_if = "Option::is_none", default)]
10565    pub pg_bouncer_config: Option<PgBouncerConfig>,
10566    #[serde(rename = "pgConfig", skip_serializing_if = "Option::is_none", default)]
10567    pub pg_config: Option<PgConfig>,
10568    #[serde(rename = "restoreTarget")]
10569    pub restore_target: PgPitrRestoreTargetProperty,
10570    #[serde(skip_serializing_if = "Option::is_none", default)]
10571    pub tags: Option<PgTags>,
10572}
10573
10574/// `PostgresServiceSetPassword` from the ClickHouse Cloud API.
10575#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10576pub struct PostgresServiceSetPassword {
10577    #[serde(default)]
10578    pub password: PgPassword,
10579}
10580
10581/// `PostgresServiceSetState` from the ClickHouse Cloud API.
10582#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10583pub struct PostgresServiceSetState {
10584    #[serde(default)]
10585    pub command: PostgresServiceSetStateCommand,
10586}
10587
10588/// `PrivateEndpointConfig` from the ClickHouse Cloud API.
10589#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10590pub struct PrivateEndpointConfig {
10591    #[serde(rename = "endpointServiceId", default)]
10592    pub endpoint_service_id: String,
10593    #[serde(rename = "privateDnsHostname", default)]
10594    pub private_dns_hostname: String,
10595}
10596
10597/// `RBACPolicy` from the ClickHouse Cloud API.
10598#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10599pub struct RBACPolicy {
10600    #[serde(rename = "allowDeny", default)]
10601    pub allow_deny: RBACPolicyAllowdeny,
10602    #[serde(default)]
10603    pub id: String,
10604    #[serde(default)]
10605    pub permissions: Vec<String>,
10606    #[serde(default)]
10607    pub resources: Vec<String>,
10608    #[serde(rename = "roleId", default)]
10609    pub role_id: String,
10610    #[serde(default)]
10611    pub tags: RBACPolicyTags,
10612    #[serde(rename = "tenantId", default)]
10613    pub tenant_id: String,
10614}
10615
10616/// `RBACPolicyCreateRequest` from the ClickHouse Cloud API.
10617#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10618pub struct RBACPolicyCreateRequest {
10619    #[serde(rename = "allowDeny")]
10620    pub allow_deny: RBACPolicyCreateRequestAllowdeny,
10621    pub permissions: Vec<String>,
10622    pub resources: Vec<String>,
10623    #[serde(skip_serializing_if = "Option::is_none", default)]
10624    pub tags: Option<RBACPolicyTags>,
10625}
10626
10627/// `RBACPolicyTags` from the ClickHouse Cloud API.
10628#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10629pub struct RBACPolicyTags {
10630    #[serde(skip_serializing_if = "Option::is_none", default)]
10631    pub grants: Option<Vec<String>>,
10632    #[serde(rename = "roleV2", skip_serializing_if = "Option::is_none", default)]
10633    pub role_v2: Option<RBACPolicyTagsRolev2>,
10634}
10635
10636/// `RBACRole` from the ClickHouse Cloud API.
10637#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10638pub struct RBACRole {
10639    #[serde(default)]
10640    pub actors: Vec<String>,
10641    #[serde(rename = "createdAt", default)]
10642    pub created_at: chrono::DateTime<chrono::Utc>,
10643    #[serde(default)]
10644    pub id: String,
10645    #[serde(default)]
10646    pub name: String,
10647    #[serde(rename = "ownerId", default)]
10648    pub owner_id: String,
10649    #[serde(default)]
10650    pub policies: Vec<RBACPolicy>,
10651    #[serde(rename = "tenantId", default)]
10652    pub tenant_id: String,
10653    #[serde(default)]
10654    pub r#type: RBACRoleType,
10655    #[serde(rename = "updatedAt", default)]
10656    pub updated_at: chrono::DateTime<chrono::Utc>,
10657}
10658
10659/// `ResourceTagsV1` from the ClickHouse Cloud API.
10660#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10661pub struct ResourceTagsV1 {
10662    pub key: String,
10663    #[serde(skip_serializing_if = "Option::is_none", default)]
10664    pub value: Option<String>,
10665}
10666
10667/// `ReversePrivateEndpoint` from the ClickHouse Cloud API.
10668#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10669pub struct ReversePrivateEndpoint {
10670    #[serde(rename = "customPrivateDnsMappings", skip_serializing_if = "Option::is_none", default)]
10671    pub custom_private_dns_mappings: Option<Vec<CustomPrivateDnsMapping>>,
10672    #[serde(default)]
10673    pub description: String,
10674    #[serde(rename = "dnsNames", default)]
10675    pub dns_names: Vec<String>,
10676    #[serde(rename = "endpointId", default)]
10677    pub endpoint_id: String,
10678    #[serde(rename = "gcpServiceAttachment", skip_serializing_if = "Option::is_none", default)]
10679    pub gcp_service_attachment: Option<String>,
10680    #[serde(default)]
10681    pub id: uuid::Uuid,
10682    #[serde(rename = "mskAuthentication", skip_serializing_if = "Option::is_none", default)]
10683    pub msk_authentication: Option<ReversePrivateEndpointMskauthentication>,
10684    #[serde(rename = "mskClusterArn", skip_serializing_if = "Option::is_none", default)]
10685    pub msk_cluster_arn: Option<String>,
10686    #[serde(rename = "privateDnsNames", default)]
10687    pub private_dns_names: Vec<String>,
10688    #[serde(rename = "serviceId", default)]
10689    pub service_id: uuid::Uuid,
10690    #[serde(default)]
10691    pub status: ReversePrivateEndpointStatus,
10692    #[serde(default)]
10693    pub r#type: ReversePrivateEndpointType,
10694    #[serde(rename = "vpcEndpointServiceName", skip_serializing_if = "Option::is_none", default)]
10695    pub vpc_endpoint_service_name: Option<String>,
10696    #[serde(rename = "vpcResourceConfigurationId", skip_serializing_if = "Option::is_none", default)]
10697    pub vpc_resource_configuration_id: Option<String>,
10698    #[serde(rename = "vpcResourceShareArn", skip_serializing_if = "Option::is_none", default)]
10699    pub vpc_resource_share_arn: Option<String>,
10700}
10701
10702/// `RoleCreateRequest` from the ClickHouse Cloud API.
10703#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10704pub struct RoleCreateRequest {
10705    pub actors: Vec<String>,
10706    pub name: String,
10707    pub policies: Vec<RBACPolicyCreateRequest>,
10708}
10709
10710/// `RoleUpdateRequest` from the ClickHouse Cloud API.
10711#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10712pub struct RoleUpdateRequest {
10713    #[serde(default)]
10714    pub actors: Vec<String>,
10715    #[serde(default)]
10716    pub name: String,
10717    #[serde(default)]
10718    pub policies: Vec<RBACPolicyCreateRequest>,
10719}
10720
10721/// `ScalingSchedule` from the ClickHouse Cloud API.
10722#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10723pub struct ScalingSchedule {
10724    #[serde(rename = "activeEntryId", skip_serializing_if = "Option::is_none", default)]
10725    pub active_entry_id: Option<uuid::Uuid>,
10726    #[serde(rename = "baseConfig", default)]
10727    pub base_config: ScalingScheduleBaseConfig,
10728    #[serde(default)]
10729    pub entries: Vec<ScalingScheduleEntry>,
10730}
10731
10732/// `ScalingScheduleBaseConfig` from the ClickHouse Cloud API.
10733#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10734pub struct ScalingScheduleBaseConfig {
10735    #[serde(rename = "idleScaling", default)]
10736    pub idle_scaling: bool,
10737    #[serde(rename = "idleTimeoutMinutes", default)]
10738    pub idle_timeout_minutes: i64,
10739    #[serde(rename = "maxReplicaMemoryGb", default)]
10740    pub max_replica_memory_gb: f64,
10741    #[serde(rename = "maxReplicas", default)]
10742    pub max_replicas: i64,
10743    #[serde(rename = "minReplicaMemoryGb", default)]
10744    pub min_replica_memory_gb: f64,
10745    #[serde(rename = "minReplicas", default)]
10746    pub min_replicas: i64,
10747}
10748
10749/// `ScalingScheduleEntry` from the ClickHouse Cloud API.
10750#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10751pub struct ScalingScheduleEntry {
10752    #[serde(rename = "endHourUtc", default)]
10753    pub end_hour_utc: i64,
10754    #[serde(default)]
10755    pub id: uuid::Uuid,
10756    #[serde(rename = "idleScaling", skip_serializing_if = "Option::is_none", default)]
10757    pub idle_scaling: Option<bool>,
10758    #[serde(rename = "idleTimeoutMinutes", skip_serializing_if = "Option::is_none", default)]
10759    pub idle_timeout_minutes: Option<i64>,
10760    #[serde(rename = "isActiveNow", default)]
10761    pub is_active_now: bool,
10762    #[serde(rename = "maxReplicaMemoryGb", skip_serializing_if = "Option::is_none", default)]
10763    pub max_replica_memory_gb: Option<f64>,
10764    #[serde(rename = "maxReplicas", skip_serializing_if = "Option::is_none", default)]
10765    pub max_replicas: Option<i64>,
10766    #[serde(rename = "minReplicaMemoryGb", skip_serializing_if = "Option::is_none", default)]
10767    pub min_replica_memory_gb: Option<f64>,
10768    #[serde(rename = "minReplicas", skip_serializing_if = "Option::is_none", default)]
10769    pub min_replicas: Option<i64>,
10770    #[serde(default)]
10771    pub name: String,
10772    #[serde(rename = "startHourUtc", default)]
10773    pub start_hour_utc: i64,
10774    #[serde(default)]
10775    pub weekdays: Vec<i64>,
10776}
10777
10778/// `ScalingScheduleEntryRequest` from the ClickHouse Cloud API.
10779#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10780pub struct ScalingScheduleEntryRequest {
10781    #[serde(rename = "endHourUtc", default)]
10782    pub end_hour_utc: i64,
10783    #[serde(rename = "idleScaling", skip_serializing_if = "Option::is_none", default)]
10784    pub idle_scaling: Option<bool>,
10785    #[serde(rename = "idleTimeoutMinutes", skip_serializing_if = "Option::is_none", default)]
10786    pub idle_timeout_minutes: Option<i64>,
10787    #[serde(rename = "maxReplicaMemoryGb", skip_serializing_if = "Option::is_none", default)]
10788    pub max_replica_memory_gb: Option<f64>,
10789    #[serde(rename = "maxReplicas", skip_serializing_if = "Option::is_none", default)]
10790    pub max_replicas: Option<i64>,
10791    #[serde(rename = "minReplicaMemoryGb", skip_serializing_if = "Option::is_none", default)]
10792    pub min_replica_memory_gb: Option<f64>,
10793    #[serde(rename = "minReplicas", skip_serializing_if = "Option::is_none", default)]
10794    pub min_replicas: Option<i64>,
10795    #[serde(default)]
10796    pub name: String,
10797    #[serde(rename = "startHourUtc", default)]
10798    pub start_hour_utc: i64,
10799    #[serde(default)]
10800    pub weekdays: Vec<i64>,
10801}
10802
10803/// `ScalingSchedulePostRequest` from the ClickHouse Cloud API.
10804#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10805pub struct ScalingSchedulePostRequest {
10806    #[serde(default)]
10807    pub entries: Vec<ScalingScheduleEntryRequest>,
10808}
10809
10810/// `ScimEnterpriseManager` from the ClickHouse Cloud API.
10811#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10812pub struct ScimEnterpriseManager {
10813    #[serde(rename = "displayName", default)]
10814    pub display_name: String,
10815    #[serde(default)]
10816    pub value: String,
10817}
10818
10819/// `ScimEnterpriseUser` from the ClickHouse Cloud API.
10820#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10821pub struct ScimEnterpriseUser {
10822    #[serde(rename = "costCenter", default)]
10823    pub cost_center: String,
10824    #[serde(default)]
10825    pub department: String,
10826    #[serde(default)]
10827    pub division: String,
10828    #[serde(rename = "employeeNumber", default)]
10829    pub employee_number: String,
10830    #[serde(default)]
10831    pub manager: ScimEnterpriseManager,
10832    #[serde(default)]
10833    pub organization: String,
10834}
10835
10836/// `ScimGroup` from the ClickHouse Cloud API.
10837#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10838pub struct ScimGroup {
10839    #[serde(rename = "displayName")]
10840    pub display_name: String,
10841    #[serde(rename = "externalId", skip_serializing_if = "Option::is_none", default)]
10842    pub external_id: Option<String>,
10843    pub id: uuid::Uuid,
10844    #[serde(skip_serializing_if = "Option::is_none", default)]
10845    pub members: Option<Vec<ScimGroupMember>>,
10846    pub meta: ScimGroupMeta,
10847    pub schemas: Vec<String>,
10848}
10849
10850/// `ScimGroupListResponse` from the ClickHouse Cloud API.
10851#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10852pub struct ScimGroupListResponse {
10853    #[serde(rename = "Resources")]
10854    pub resources: Vec<ScimGroup>,
10855    #[serde(rename = "itemsPerPage")]
10856    pub items_per_page: i64,
10857    pub schemas: Vec<String>,
10858    #[serde(rename = "startIndex")]
10859    pub start_index: i64,
10860    #[serde(rename = "totalResults")]
10861    pub total_results: i64,
10862}
10863
10864/// `ScimGroupMember` from the ClickHouse Cloud API.
10865#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10866pub struct ScimGroupMember {
10867    #[serde(skip_serializing_if = "Option::is_none", default)]
10868    pub display: Option<String>,
10869    #[serde(skip_serializing_if = "Option::is_none", default)]
10870    pub r#type: Option<String>,
10871    pub value: String,
10872}
10873
10874/// `ScimGroupMeta` from the ClickHouse Cloud API.
10875#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10876pub struct ScimGroupMeta {
10877    pub created: chrono::DateTime<chrono::Utc>,
10878    #[serde(rename = "lastModified")]
10879    pub last_modified: chrono::DateTime<chrono::Utc>,
10880    #[serde(skip_serializing_if = "Option::is_none", default)]
10881    pub location: Option<String>,
10882    #[serde(rename = "resourceType")]
10883    pub resource_type: String,
10884}
10885
10886/// `ScimGroupPostRequest` from the ClickHouse Cloud API.
10887#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10888pub struct ScimGroupPostRequest {
10889    #[serde(rename = "displayName")]
10890    pub display_name: String,
10891    #[serde(rename = "externalId", skip_serializing_if = "Option::is_none", default)]
10892    pub external_id: Option<String>,
10893    #[serde(skip_serializing_if = "Option::is_none", default)]
10894    pub members: Option<Vec<ScimGroupMember>>,
10895    pub schemas: Vec<String>,
10896}
10897
10898/// `ScimGroupPutRequest` from the ClickHouse Cloud API.
10899#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10900pub struct ScimGroupPutRequest {
10901    #[serde(rename = "displayName")]
10902    pub display_name: String,
10903    #[serde(rename = "externalId", skip_serializing_if = "Option::is_none", default)]
10904    pub external_id: Option<String>,
10905    #[serde(skip_serializing_if = "Option::is_none", default)]
10906    pub id: Option<String>,
10907    #[serde(skip_serializing_if = "Option::is_none", default)]
10908    pub members: Option<Vec<ScimGroupMember>>,
10909    #[serde(skip_serializing_if = "Option::is_none", default)]
10910    pub meta: Option<ScimGroupMeta>,
10911    pub schemas: Vec<String>,
10912}
10913
10914/// `ScimListResponse` from the ClickHouse Cloud API.
10915#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10916pub struct ScimListResponse {
10917    #[serde(rename = "Resources")]
10918    pub resources: Vec<ScimUser>,
10919    #[serde(rename = "itemsPerPage")]
10920    pub items_per_page: i64,
10921    pub schemas: Vec<String>,
10922    #[serde(rename = "startIndex")]
10923    pub start_index: i64,
10924    #[serde(rename = "totalResults")]
10925    pub total_results: i64,
10926}
10927
10928/// `ScimPatchOp` from the ClickHouse Cloud API.
10929#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10930pub struct ScimPatchOp {
10931    #[serde(rename = "Operations")]
10932    pub operations: Vec<ScimPatchOperation>,
10933    pub schemas: Vec<String>,
10934}
10935
10936/// `ScimPatchOperation` from the ClickHouse Cloud API.
10937#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10938pub struct ScimPatchOperation {
10939    pub op: ScimPatchOperationOp,
10940    #[serde(skip_serializing_if = "Option::is_none", default)]
10941    pub path: Option<String>,
10942    #[serde(skip_serializing_if = "Option::is_none", default)]
10943    pub value: Option<String>,
10944}
10945
10946/// `ScimUser` from the ClickHouse Cloud API.
10947#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10948pub struct ScimUser {
10949    pub active: bool,
10950    #[serde(skip_serializing_if = "Option::is_none", default)]
10951    pub addresses: Option<Vec<ScimUserAddress>>,
10952    #[serde(rename = "displayName", skip_serializing_if = "Option::is_none", default)]
10953    pub display_name: Option<String>,
10954    pub emails: Vec<ScimUserEmail>,
10955    #[serde(skip_serializing_if = "Option::is_none", default)]
10956    pub entitlements: Option<Vec<ScimUserEntitlement>>,
10957    #[serde(rename = "externalId", skip_serializing_if = "Option::is_none", default)]
10958    pub external_id: Option<String>,
10959    #[serde(skip_serializing_if = "Option::is_none", default)]
10960    pub groups: Option<Vec<ScimUserGroup>>,
10961    pub id: String,
10962    #[serde(skip_serializing_if = "Option::is_none", default)]
10963    pub ims: Option<Vec<ScimUserIm>>,
10964    #[serde(skip_serializing_if = "Option::is_none", default)]
10965    pub locale: Option<String>,
10966    pub meta: ScimUserMeta,
10967    pub name: ScimUserName,
10968    #[serde(rename = "nickName", skip_serializing_if = "Option::is_none", default)]
10969    pub nick_name: Option<String>,
10970    #[serde(rename = "phoneNumbers", skip_serializing_if = "Option::is_none", default)]
10971    pub phone_numbers: Option<Vec<ScimUserPhoneNumber>>,
10972    #[serde(skip_serializing_if = "Option::is_none", default)]
10973    pub photos: Option<Vec<ScimUserPhoto>>,
10974    #[serde(rename = "preferredLanguage", skip_serializing_if = "Option::is_none", default)]
10975    pub preferred_language: Option<String>,
10976    #[serde(rename = "profileUrl", skip_serializing_if = "Option::is_none", default)]
10977    pub profile_url: Option<String>,
10978    #[serde(skip_serializing_if = "Option::is_none", default)]
10979    pub roles: Option<Vec<ScimUserRole>>,
10980    pub schemas: Vec<String>,
10981    #[serde(skip_serializing_if = "Option::is_none", default)]
10982    pub timezone: Option<String>,
10983    #[serde(skip_serializing_if = "Option::is_none", default)]
10984    pub title: Option<String>,
10985    #[serde(rename = "userName")]
10986    pub user_name: String,
10987    #[serde(rename = "userType", skip_serializing_if = "Option::is_none", default)]
10988    pub user_type: Option<String>,
10989    #[serde(rename = "x509Certificates", skip_serializing_if = "Option::is_none", default)]
10990    pub x509_certificates: Option<Vec<ScimX509Certificate>>,
10991}
10992
10993/// `ScimUserAddress` from the ClickHouse Cloud API.
10994#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
10995pub struct ScimUserAddress {
10996    #[serde(default)]
10997    pub country: String,
10998    #[serde(default)]
10999    pub formatted: String,
11000    #[serde(default)]
11001    pub locality: String,
11002    #[serde(rename = "postalCode", default)]
11003    pub postal_code: String,
11004    #[serde(default)]
11005    pub primary: bool,
11006    #[serde(default)]
11007    pub region: String,
11008    #[serde(rename = "streetAddress", default)]
11009    pub street_address: String,
11010    #[serde(default)]
11011    pub r#type: String,
11012}
11013
11014/// `ScimUserEmail` from the ClickHouse Cloud API.
11015#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11016pub struct ScimUserEmail {
11017    #[serde(skip_serializing_if = "Option::is_none", default)]
11018    pub primary: Option<bool>,
11019    #[serde(skip_serializing_if = "Option::is_none", default)]
11020    pub r#type: Option<String>,
11021    pub value: String,
11022}
11023
11024/// `ScimUserEntitlement` from the ClickHouse Cloud API.
11025#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11026pub struct ScimUserEntitlement {
11027    #[serde(default)]
11028    pub display: String,
11029    #[serde(default)]
11030    pub primary: bool,
11031    #[serde(default)]
11032    pub r#type: String,
11033    #[serde(default)]
11034    pub value: String,
11035}
11036
11037/// `ScimUserGroup` from the ClickHouse Cloud API.
11038#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11039pub struct ScimUserGroup {
11040    #[serde(default)]
11041    pub display: String,
11042    #[serde(default)]
11043    pub r#type: String,
11044    #[serde(default)]
11045    pub value: String,
11046}
11047
11048/// `ScimUserIm` from the ClickHouse Cloud API.
11049#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11050pub struct ScimUserIm {
11051    #[serde(default)]
11052    pub primary: bool,
11053    #[serde(default)]
11054    pub r#type: String,
11055    #[serde(default)]
11056    pub value: String,
11057}
11058
11059/// `ScimUserMeta` from the ClickHouse Cloud API.
11060#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11061pub struct ScimUserMeta {
11062    pub created: chrono::DateTime<chrono::Utc>,
11063    #[serde(rename = "lastModified")]
11064    pub last_modified: chrono::DateTime<chrono::Utc>,
11065    #[serde(skip_serializing_if = "Option::is_none", default)]
11066    pub location: Option<String>,
11067    #[serde(rename = "resourceType")]
11068    pub resource_type: String,
11069}
11070
11071/// `ScimUserName` from the ClickHouse Cloud API.
11072#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11073pub struct ScimUserName {
11074    #[serde(rename = "familyName", default)]
11075    pub family_name: String,
11076    #[serde(default)]
11077    pub formatted: String,
11078    #[serde(rename = "givenName", default)]
11079    pub given_name: String,
11080    #[serde(rename = "honorificPrefix", default)]
11081    pub honorific_prefix: String,
11082    #[serde(rename = "honorificSuffix", default)]
11083    pub honorific_suffix: String,
11084    #[serde(rename = "middleName", default)]
11085    pub middle_name: String,
11086}
11087
11088/// `ScimUserPhoneNumber` from the ClickHouse Cloud API.
11089#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11090pub struct ScimUserPhoneNumber {
11091    #[serde(default)]
11092    pub primary: bool,
11093    #[serde(default)]
11094    pub r#type: String,
11095    #[serde(default)]
11096    pub value: String,
11097}
11098
11099/// `ScimUserPhoto` from the ClickHouse Cloud API.
11100#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11101pub struct ScimUserPhoto {
11102    #[serde(default)]
11103    pub primary: bool,
11104    #[serde(default)]
11105    pub r#type: String,
11106    #[serde(default)]
11107    pub value: String,
11108}
11109
11110/// `ScimUserPostRequest` from the ClickHouse Cloud API.
11111#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11112pub struct ScimUserPostRequest {
11113    #[serde(skip_serializing_if = "Option::is_none", default)]
11114    pub active: Option<bool>,
11115    #[serde(skip_serializing_if = "Option::is_none", default)]
11116    pub addresses: Option<Vec<ScimUserAddress>>,
11117    #[serde(rename = "displayName", skip_serializing_if = "Option::is_none", default)]
11118    pub display_name: Option<String>,
11119    pub emails: Vec<ScimUserEmail>,
11120    #[serde(skip_serializing_if = "Option::is_none", default)]
11121    pub entitlements: Option<Vec<ScimUserEntitlement>>,
11122    #[serde(rename = "externalId", skip_serializing_if = "Option::is_none", default)]
11123    pub external_id: Option<String>,
11124    #[serde(skip_serializing_if = "Option::is_none", default)]
11125    pub groups: Option<Vec<ScimUserGroup>>,
11126    #[serde(skip_serializing_if = "Option::is_none", default)]
11127    pub ims: Option<Vec<ScimUserIm>>,
11128    #[serde(skip_serializing_if = "Option::is_none", default)]
11129    pub locale: Option<String>,
11130    #[serde(skip_serializing_if = "Option::is_none", default)]
11131    pub name: Option<ScimUserName>,
11132    #[serde(rename = "nickName", skip_serializing_if = "Option::is_none", default)]
11133    pub nick_name: Option<String>,
11134    #[serde(skip_serializing_if = "Option::is_none", default)]
11135    pub password: Option<String>,
11136    #[serde(rename = "phoneNumbers", skip_serializing_if = "Option::is_none", default)]
11137    pub phone_numbers: Option<Vec<ScimUserPhoneNumber>>,
11138    #[serde(skip_serializing_if = "Option::is_none", default)]
11139    pub photos: Option<Vec<ScimUserPhoto>>,
11140    #[serde(rename = "preferredLanguage", skip_serializing_if = "Option::is_none", default)]
11141    pub preferred_language: Option<String>,
11142    #[serde(rename = "profileUrl", skip_serializing_if = "Option::is_none", default)]
11143    pub profile_url: Option<String>,
11144    #[serde(skip_serializing_if = "Option::is_none", default)]
11145    pub roles: Option<Vec<ScimUserRole>>,
11146    pub schemas: Vec<String>,
11147    #[serde(skip_serializing_if = "Option::is_none", default)]
11148    pub timezone: Option<String>,
11149    #[serde(skip_serializing_if = "Option::is_none", default)]
11150    pub title: Option<String>,
11151    #[serde(rename = "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User", skip_serializing_if = "Option::is_none", default)]
11152    pub urn_ietf_params_scim_schemas_extension_enterprise_2_0_user: Option<ScimEnterpriseUser>,
11153    #[serde(rename = "userName")]
11154    pub user_name: String,
11155    #[serde(rename = "userType", skip_serializing_if = "Option::is_none", default)]
11156    pub user_type: Option<String>,
11157    #[serde(rename = "x509Certificates", skip_serializing_if = "Option::is_none", default)]
11158    pub x509_certificates: Option<Vec<ScimX509Certificate>>,
11159}
11160
11161/// `ScimUserPutRequest` from the ClickHouse Cloud API.
11162#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11163pub struct ScimUserPutRequest {
11164    #[serde(skip_serializing_if = "Option::is_none", default)]
11165    pub active: Option<bool>,
11166    #[serde(skip_serializing_if = "Option::is_none", default)]
11167    pub addresses: Option<Vec<ScimUserAddress>>,
11168    #[serde(rename = "displayName", skip_serializing_if = "Option::is_none", default)]
11169    pub display_name: Option<String>,
11170    pub emails: Vec<ScimUserEmail>,
11171    #[serde(skip_serializing_if = "Option::is_none", default)]
11172    pub entitlements: Option<Vec<ScimUserEntitlement>>,
11173    #[serde(rename = "externalId", skip_serializing_if = "Option::is_none", default)]
11174    pub external_id: Option<String>,
11175    #[serde(skip_serializing_if = "Option::is_none", default)]
11176    pub groups: Option<Vec<ScimUserGroup>>,
11177    #[serde(skip_serializing_if = "Option::is_none", default)]
11178    pub id: Option<String>,
11179    #[serde(skip_serializing_if = "Option::is_none", default)]
11180    pub ims: Option<Vec<ScimUserIm>>,
11181    #[serde(skip_serializing_if = "Option::is_none", default)]
11182    pub locale: Option<String>,
11183    #[serde(skip_serializing_if = "Option::is_none", default)]
11184    pub meta: Option<ScimUserMeta>,
11185    #[serde(skip_serializing_if = "Option::is_none", default)]
11186    pub name: Option<ScimUserName>,
11187    #[serde(rename = "nickName", skip_serializing_if = "Option::is_none", default)]
11188    pub nick_name: Option<String>,
11189    #[serde(skip_serializing_if = "Option::is_none", default)]
11190    pub password: Option<String>,
11191    #[serde(rename = "phoneNumbers", skip_serializing_if = "Option::is_none", default)]
11192    pub phone_numbers: Option<Vec<ScimUserPhoneNumber>>,
11193    #[serde(skip_serializing_if = "Option::is_none", default)]
11194    pub photos: Option<Vec<ScimUserPhoto>>,
11195    #[serde(rename = "preferredLanguage", skip_serializing_if = "Option::is_none", default)]
11196    pub preferred_language: Option<String>,
11197    #[serde(rename = "profileUrl", skip_serializing_if = "Option::is_none", default)]
11198    pub profile_url: Option<String>,
11199    #[serde(skip_serializing_if = "Option::is_none", default)]
11200    pub roles: Option<Vec<ScimUserRole>>,
11201    pub schemas: Vec<String>,
11202    #[serde(skip_serializing_if = "Option::is_none", default)]
11203    pub timezone: Option<String>,
11204    #[serde(skip_serializing_if = "Option::is_none", default)]
11205    pub title: Option<String>,
11206    #[serde(rename = "urn:ietf:params:scim:schemas:extension:enterprise:2.0:User", skip_serializing_if = "Option::is_none", default)]
11207    pub urn_ietf_params_scim_schemas_extension_enterprise_2_0_user: Option<ScimEnterpriseUser>,
11208    #[serde(rename = "userName")]
11209    pub user_name: String,
11210    #[serde(rename = "userType", skip_serializing_if = "Option::is_none", default)]
11211    pub user_type: Option<String>,
11212    #[serde(rename = "x509Certificates", skip_serializing_if = "Option::is_none", default)]
11213    pub x509_certificates: Option<Vec<ScimX509Certificate>>,
11214}
11215
11216/// `ScimUserRole` from the ClickHouse Cloud API.
11217#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11218pub struct ScimUserRole {
11219    #[serde(default)]
11220    pub display: String,
11221    #[serde(default)]
11222    pub primary: bool,
11223    #[serde(default)]
11224    pub r#type: String,
11225    #[serde(default)]
11226    pub value: String,
11227}
11228
11229/// `ScimX509Certificate` from the ClickHouse Cloud API.
11230#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11231pub struct ScimX509Certificate {
11232    #[serde(default)]
11233    pub value: String,
11234}
11235
11236/// `ScimAuthenticationScheme` from the ClickHouse Cloud API.
11237#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11238pub struct ScimAuthenticationScheme {
11239    pub description: String,
11240    pub name: String,
11241    #[serde(skip_serializing_if = "Option::is_none", default)]
11242    pub primary: Option<bool>,
11243    #[serde(rename = "specUri", skip_serializing_if = "Option::is_none", default)]
11244    pub spec_uri: Option<String>,
11245    #[serde(rename = "type")]
11246    pub r#type: String,
11247}
11248
11249/// `ScimBooleanFeature` from the ClickHouse Cloud API.
11250#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11251pub struct ScimBooleanFeature {
11252    pub supported: bool,
11253}
11254
11255/// `ScimResourceType` from the ClickHouse Cloud API.
11256#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11257pub struct ScimResourceType {
11258    pub description: String,
11259    pub endpoint: String,
11260    pub id: String,
11261    pub meta: ScimResourceTypeMeta,
11262    pub name: String,
11263    pub schema: String,
11264    #[serde(rename = "schemaExtensions")]
11265    pub schema_extensions: Vec<ScimSchemaExtension>,
11266    pub schemas: Vec<String>,
11267}
11268
11269/// `ScimResourceTypeListResponse` from the ClickHouse Cloud API.
11270#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11271pub struct ScimResourceTypeListResponse {
11272    #[serde(rename = "Resources")]
11273    pub resources: Vec<ScimResourceType>,
11274    #[serde(rename = "itemsPerPage")]
11275    pub items_per_page: i64,
11276    pub schemas: Vec<String>,
11277    #[serde(rename = "startIndex")]
11278    pub start_index: i64,
11279    #[serde(rename = "totalResults")]
11280    pub total_results: i64,
11281}
11282
11283/// `ScimResourceTypeMeta` from the ClickHouse Cloud API.
11284#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11285pub struct ScimResourceTypeMeta {
11286    pub location: String,
11287    #[serde(rename = "resourceType")]
11288    pub resource_type: String,
11289}
11290
11291/// `ScimSchema` from the ClickHouse Cloud API.
11292#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11293pub struct ScimSchema {
11294    pub attributes: Vec<ScimSchemaAttribute>,
11295    pub description: String,
11296    pub id: String,
11297    pub meta: ScimSchemaMeta,
11298    pub name: String,
11299    pub schemas: Vec<String>,
11300}
11301
11302/// `ScimSchemaAttribute` from the ClickHouse Cloud API.
11303#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11304pub struct ScimSchemaAttribute {
11305    #[serde(rename = "canonicalValues", skip_serializing_if = "Option::is_none", default)]
11306    pub canonical_values: Option<Vec<String>>,
11307    #[serde(rename = "caseExact", skip_serializing_if = "Option::is_none", default)]
11308    pub case_exact: Option<bool>,
11309    pub description: String,
11310    #[serde(rename = "multiValued")]
11311    pub multi_valued: bool,
11312    pub mutability: String,
11313    pub name: String,
11314    #[serde(rename = "referenceTypes", skip_serializing_if = "Option::is_none", default)]
11315    pub reference_types: Option<Vec<String>>,
11316    pub required: bool,
11317    pub returned: String,
11318    #[serde(rename = "subAttributes", skip_serializing_if = "Option::is_none", default)]
11319    pub sub_attributes: Option<Vec<ScimSchemaAttribute>>,
11320    #[serde(rename = "type")]
11321    pub r#type: String,
11322    #[serde(skip_serializing_if = "Option::is_none", default)]
11323    pub uniqueness: Option<String>,
11324}
11325
11326/// `ScimSchemaExtension` from the ClickHouse Cloud API.
11327#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11328pub struct ScimSchemaExtension {
11329    pub required: bool,
11330    pub schema: String,
11331}
11332
11333/// `ScimSchemaListResponse` from the ClickHouse Cloud API.
11334#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11335pub struct ScimSchemaListResponse {
11336    #[serde(rename = "Resources")]
11337    pub resources: Vec<ScimSchema>,
11338    #[serde(rename = "itemsPerPage")]
11339    pub items_per_page: i64,
11340    pub schemas: Vec<String>,
11341    #[serde(rename = "startIndex")]
11342    pub start_index: i64,
11343    #[serde(rename = "totalResults")]
11344    pub total_results: i64,
11345}
11346
11347/// `ScimSchemaMeta` from the ClickHouse Cloud API.
11348#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11349pub struct ScimSchemaMeta {
11350    pub location: String,
11351    #[serde(rename = "resourceType")]
11352    pub resource_type: String,
11353}
11354
11355/// `ScimServiceProviderConfig` from the ClickHouse Cloud API.
11356#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11357pub struct ScimServiceProviderConfig {
11358    #[serde(rename = "authenticationSchemes")]
11359    pub authentication_schemes: Vec<ScimAuthenticationScheme>,
11360    pub bulk: ScimServiceProviderConfigBulk,
11361    #[serde(rename = "changePassword")]
11362    pub change_password: ScimBooleanFeature,
11363    #[serde(rename = "documentationUri", skip_serializing_if = "Option::is_none", default)]
11364    pub documentation_uri: Option<String>,
11365    pub etag: ScimBooleanFeature,
11366    pub filter: ScimServiceProviderConfigFilter,
11367    pub meta: ScimServiceProviderConfigMeta,
11368    pub patch: ScimServiceProviderConfigPatch,
11369    pub schemas: Vec<String>,
11370    pub sort: ScimBooleanFeature,
11371}
11372
11373/// `ScimServiceProviderConfigBulk` from the ClickHouse Cloud API.
11374#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11375pub struct ScimServiceProviderConfigBulk {
11376    #[serde(rename = "maxOperations")]
11377    pub max_operations: i64,
11378    #[serde(rename = "maxPayloadSize")]
11379    pub max_payload_size: i64,
11380    pub supported: bool,
11381}
11382
11383/// `ScimServiceProviderConfigFilter` from the ClickHouse Cloud API.
11384#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11385pub struct ScimServiceProviderConfigFilter {
11386    #[serde(rename = "maxResults")]
11387    pub max_results: i64,
11388    pub supported: bool,
11389}
11390
11391/// `ScimServiceProviderConfigMeta` from the ClickHouse Cloud API.
11392#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11393pub struct ScimServiceProviderConfigMeta {
11394    pub location: String,
11395    #[serde(rename = "resourceType")]
11396    pub resource_type: String,
11397}
11398
11399/// `ScimServiceProviderConfigPatch` from the ClickHouse Cloud API.
11400#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11401pub struct ScimServiceProviderConfigPatch {
11402    pub supported: bool,
11403}
11404
11405/// `ServicPrivateEndpointePostRequest` from the ClickHouse Cloud API.
11406#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11407pub struct ServicPrivateEndpointePostRequest {
11408    #[serde(default)]
11409    pub description: String,
11410    #[serde(default)]
11411    pub id: String,
11412}
11413
11414/// `Service` from the ClickHouse Cloud API.
11415#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11416pub struct Service {
11417    #[serde(rename = "availablePrivateEndpointIds", default)]
11418    pub available_private_endpoint_ids: Vec<String>,
11419    #[serde(rename = "byocId", default)]
11420    pub byoc_id: String,
11421    #[serde(rename = "clickhouseVersion", default)]
11422    pub clickhouse_version: String,
11423    #[serde(rename = "complianceType", default)]
11424    pub compliance_type: ServiceCompliancetype,
11425    #[serde(rename = "createdAt", default)]
11426    pub created_at: chrono::DateTime<chrono::Utc>,
11427    #[serde(rename = "currentScaling", default)]
11428    pub current_scaling: CurrentScaling,
11429    #[serde(rename = "dataWarehouseId", default)]
11430    pub data_warehouse_id: String,
11431    #[serde(rename = "enableCoreDumps", default)]
11432    pub enable_core_dumps: bool,
11433    #[serde(rename = "encryptionAssumedRoleIdentifier", skip_serializing_if = "Option::is_none", default)]
11434    pub encryption_assumed_role_identifier: Option<String>,
11435    #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none", default)]
11436    pub encryption_key: Option<String>,
11437    #[serde(rename = "encryptionRoleId", default)]
11438    pub encryption_role_id: String,
11439    #[serde(default)]
11440    pub endpoints: Vec<ServiceEndpoint>,
11441    #[serde(rename = "hasTransparentDataEncryption", default)]
11442    pub has_transparent_data_encryption: bool,
11443    #[serde(rename = "iamRole", default)]
11444    pub iam_role: String,
11445    #[serde(default)]
11446    pub id: uuid::Uuid,
11447    #[serde(rename = "idleScaling", default)]
11448    pub idle_scaling: bool,
11449    #[serde(rename = "idleTimeoutMinutes", default)]
11450    pub idle_timeout_minutes: f64,
11451    #[serde(rename = "ipAccessList", default)]
11452    pub ip_access_list: Vec<IpAccessListEntry>,
11453    #[serde(rename = "isPrimary", default)]
11454    pub is_primary: bool,
11455    #[serde(rename = "isReadonly", default)]
11456    pub is_readonly: bool,
11457    #[serde(rename = "maxReplicaMemoryGb", default)]
11458    pub max_replica_memory_gb: f64,
11459    #[serde(rename = "maxReplicas", default)]
11460    pub max_replicas: f64,
11461    #[cfg(feature = "deprecated-fields")]
11462    #[serde(rename = "maxTotalMemoryGb", default)]
11463    pub max_total_memory_gb: f64,
11464    #[serde(rename = "minReplicaMemoryGb", default)]
11465    pub min_replica_memory_gb: f64,
11466    #[serde(rename = "minReplicas", default)]
11467    pub min_replicas: f64,
11468    #[cfg(feature = "deprecated-fields")]
11469    #[serde(rename = "minTotalMemoryGb", default)]
11470    pub min_total_memory_gb: f64,
11471    #[serde(default)]
11472    pub name: String,
11473    #[serde(rename = "numReplicas", default)]
11474    pub num_replicas: f64,
11475    #[serde(rename = "privateEndpointIds", default)]
11476    pub private_endpoint_ids: Vec<String>,
11477    #[serde(default)]
11478    pub profile: ServiceProfile,
11479    #[serde(default)]
11480    pub provider: ServiceProvider,
11481    #[serde(default)]
11482    pub region: ServiceRegion,
11483    #[serde(rename = "releaseChannel", default)]
11484    pub release_channel: ServiceReleasechannel,
11485    #[serde(rename = "replicaMemoryGb", default)]
11486    pub replica_memory_gb: f64,
11487    #[serde(rename = "scalingSchedule", default)]
11488    pub scaling_schedule: ScalingSchedule,
11489    #[serde(default)]
11490    pub state: ServiceState,
11491    #[serde(default)]
11492    pub tags: Vec<ResourceTagsV1>,
11493    #[cfg(feature = "deprecated-fields")]
11494    #[serde(default)]
11495    pub tier: ServiceTier,
11496    #[serde(rename = "transparentDataEncryptionKeyId", default)]
11497    pub transparent_data_encryption_key_id: String,
11498}
11499
11500/// `ServiceAccount` from the ClickHouse Cloud API.
11501#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11502pub struct ServiceAccount {
11503    #[serde(rename = "serviceAccountFile", default)]
11504    pub service_account_file: String,
11505}
11506
11507/// `ServiceClickhouseSetting` from the ClickHouse Cloud API.
11508#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11509pub struct ServiceClickhouseSetting {
11510    #[serde(default)]
11511    pub name: String,
11512    #[serde(default)]
11513    pub value: String,
11514}
11515
11516/// `ServiceClickhouseSettingSchemaEntry` from the ClickHouse Cloud API.
11517#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11518pub struct ServiceClickhouseSettingSchemaEntry {
11519    #[serde(rename = "deprecationNotice", default)]
11520    pub deprecation_notice: String,
11521    #[serde(default)]
11522    pub description: String,
11523    #[serde(default)]
11524    pub r#enum: Vec<i64>,
11525    #[serde(default)]
11526    pub example: String,
11527    #[serde(default)]
11528    pub name: String,
11529    #[serde(default)]
11530    pub r#type: String,
11531    #[serde(default)]
11532    pub warning: String,
11533}
11534
11535/// `ServiceClickhouseSettingWarning` from the ClickHouse Cloud API.
11536#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11537pub struct ServiceClickhouseSettingWarning {
11538    #[serde(default)]
11539    pub message: String,
11540    #[serde(default)]
11541    pub name: String,
11542}
11543
11544/// `ServiceClickhouseSettingsList` from the ClickHouse Cloud API.
11545#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11546pub struct ServiceClickhouseSettingsList {
11547    #[serde(default)]
11548    pub settings: Vec<ServiceClickhouseSetting>,
11549}
11550
11551/// `ServiceClickhouseSettingsPatchRequest` from the ClickHouse Cloud API.
11552#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11553pub struct ServiceClickhouseSettingsPatchRequest {
11554    #[serde(skip_serializing_if = "Option::is_none", default)]
11555    pub settings: Option<String>,
11556}
11557
11558/// `ServiceClickhouseSettingsPatchResponse` from the ClickHouse Cloud API.
11559#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11560pub struct ServiceClickhouseSettingsPatchResponse {
11561    #[serde(default)]
11562    pub settings: String,
11563    #[serde(default)]
11564    pub warnings: Vec<ServiceClickhouseSettingWarning>,
11565}
11566
11567/// `ServiceClickhouseSettingsSchema` from the ClickHouse Cloud API.
11568#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11569pub struct ServiceClickhouseSettingsSchema {
11570    #[serde(default)]
11571    pub settings: Vec<ServiceClickhouseSettingSchemaEntry>,
11572}
11573
11574/// `ServiceEndpoint` from the ClickHouse Cloud API.
11575#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11576pub struct ServiceEndpoint {
11577    #[serde(default)]
11578    pub host: String,
11579    #[serde(default)]
11580    pub port: f64,
11581    #[serde(default)]
11582    pub protocol: ServiceEndpointProtocol,
11583    #[serde(skip_serializing_if = "Option::is_none", default)]
11584    pub username: Option<String>,
11585}
11586
11587/// `ServiceEndpointChange` from the ClickHouse Cloud API.
11588#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11589pub struct ServiceEndpointChange {
11590    #[serde(default)]
11591    pub enabled: bool,
11592    #[serde(default)]
11593    pub protocol: ServiceEndpointChangeProtocol,
11594}
11595
11596/// `ServicePasswordPatchRequest` from the ClickHouse Cloud API.
11597#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11598pub struct ServicePasswordPatchRequest {
11599    #[serde(rename = "newDoubleSha1Hash", skip_serializing_if = "Option::is_none", default)]
11600    pub new_double_sha1_hash: Option<String>,
11601    #[serde(rename = "newPasswordHash", skip_serializing_if = "Option::is_none", default)]
11602    pub new_password_hash: Option<String>,
11603}
11604
11605/// `ServicePasswordPatchResponse` from the ClickHouse Cloud API.
11606#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11607pub struct ServicePasswordPatchResponse {
11608    #[serde(default)]
11609    pub password: String,
11610}
11611
11612/// `ServicePatchRequest` from the ClickHouse Cloud API.
11613#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11614pub struct ServicePatchRequest {
11615    #[serde(rename = "enableCoreDumps", skip_serializing_if = "Option::is_none", default)]
11616    pub enable_core_dumps: Option<bool>,
11617    #[serde(skip_serializing_if = "Option::is_none", default)]
11618    pub endpoints: Option<Vec<ServiceEndpointChange>>,
11619    #[serde(rename = "ipAccessList", skip_serializing_if = "Option::is_none", default)]
11620    pub ip_access_list: Option<IpAccessListPatch>,
11621    #[serde(skip_serializing_if = "Option::is_none", default)]
11622    pub name: Option<String>,
11623    #[serde(rename = "privateEndpointIds", skip_serializing_if = "Option::is_none", default)]
11624    pub private_endpoint_ids: Option<InstancePrivateEndpointsPatch>,
11625    #[serde(rename = "releaseChannel", skip_serializing_if = "Option::is_none", default)]
11626    pub release_channel: Option<ServicePatchRequestReleasechannel>,
11627    #[serde(skip_serializing_if = "Option::is_none", default)]
11628    pub tags: Option<InstanceTagsPatch>,
11629    #[serde(rename = "transparentDataEncryptionKeyId", skip_serializing_if = "Option::is_none", default)]
11630    pub transparent_data_encryption_key_id: Option<String>,
11631}
11632
11633/// `ServicePostRequest` from the ClickHouse Cloud API.
11634#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11635pub struct ServicePostRequest {
11636    #[serde(rename = "backupId", skip_serializing_if = "Option::is_none", default)]
11637    pub backup_id: Option<uuid::Uuid>,
11638    #[serde(rename = "byocId", skip_serializing_if = "Option::is_none", default)]
11639    pub byoc_id: Option<String>,
11640    #[serde(rename = "complianceType", skip_serializing_if = "Option::is_none", default)]
11641    pub compliance_type: Option<ServicePostRequestCompliancetype>,
11642    #[serde(rename = "dataWarehouseId", skip_serializing_if = "Option::is_none", default)]
11643    pub data_warehouse_id: Option<String>,
11644    #[serde(rename = "enableCoreDumps", skip_serializing_if = "Option::is_none", default)]
11645    pub enable_core_dumps: Option<bool>,
11646    #[serde(rename = "encryptionAssumedRoleIdentifier", skip_serializing_if = "Option::is_none", default)]
11647    pub encryption_assumed_role_identifier: Option<String>,
11648    #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none", default)]
11649    pub encryption_key: Option<String>,
11650    #[serde(skip_serializing_if = "Option::is_none", default)]
11651    pub endpoints: Option<Vec<ServiceEndpointChange>>,
11652    #[serde(rename = "hasTransparentDataEncryption", skip_serializing_if = "Option::is_none", default)]
11653    pub has_transparent_data_encryption: Option<bool>,
11654    #[serde(rename = "idleScaling", skip_serializing_if = "Option::is_none", default)]
11655    pub idle_scaling: Option<bool>,
11656    #[serde(rename = "idleTimeoutMinutes", skip_serializing_if = "Option::is_none", default)]
11657    pub idle_timeout_minutes: Option<f64>,
11658    #[serde(rename = "ipAccessList", default)]
11659    pub ip_access_list: Vec<IpAccessListEntry>,
11660    #[serde(rename = "isReadonly", skip_serializing_if = "Option::is_none", default)]
11661    pub is_readonly: Option<bool>,
11662    #[serde(rename = "maxReplicaMemoryGb", skip_serializing_if = "Option::is_none", default)]
11663    pub max_replica_memory_gb: Option<f64>,
11664    #[cfg(feature = "deprecated-fields")]
11665    #[serde(rename = "maxTotalMemoryGb", skip_serializing_if = "Option::is_none", default)]
11666    pub max_total_memory_gb: Option<f64>,
11667    #[serde(rename = "minReplicaMemoryGb", skip_serializing_if = "Option::is_none", default)]
11668    pub min_replica_memory_gb: Option<f64>,
11669    #[cfg(feature = "deprecated-fields")]
11670    #[serde(rename = "minTotalMemoryGb", skip_serializing_if = "Option::is_none", default)]
11671    pub min_total_memory_gb: Option<f64>,
11672    #[serde(default)]
11673    pub name: String,
11674    #[serde(rename = "numReplicas", skip_serializing_if = "Option::is_none", default)]
11675    pub num_replicas: Option<f64>,
11676    #[cfg(feature = "deprecated-fields")]
11677    #[serde(rename = "privateEndpointIds", skip_serializing_if = "Option::is_none", default)]
11678    pub private_endpoint_ids: Option<Vec<String>>,
11679    #[serde(rename = "privatePreviewTermsChecked", skip_serializing_if = "Option::is_none", default)]
11680    pub private_preview_terms_checked: Option<bool>,
11681    #[serde(skip_serializing_if = "Option::is_none", default)]
11682    pub profile: Option<ServicePostRequestProfile>,
11683    #[serde(default)]
11684    pub provider: ServicePostRequestProvider,
11685    #[serde(default)]
11686    pub region: ServicePostRequestRegion,
11687    #[serde(rename = "releaseChannel", skip_serializing_if = "Option::is_none", default)]
11688    pub release_channel: Option<ServicePostRequestReleasechannel>,
11689    #[serde(skip_serializing_if = "Option::is_none", default)]
11690    pub tags: Option<Vec<ResourceTagsV1>>,
11691    #[cfg(feature = "deprecated-fields")]
11692    #[serde(skip_serializing_if = "Option::is_none", default)]
11693    pub tier: Option<ServicePostRequestTier>,
11694}
11695
11696/// `ServicePostResponse` from the ClickHouse Cloud API.
11697#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11698pub struct ServicePostResponse {
11699    #[serde(default)]
11700    pub password: String,
11701    #[serde(default)]
11702    pub service: Service,
11703}
11704
11705/// `ServiceQueryAPIEndpoint` from the ClickHouse Cloud API.
11706#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11707pub struct ServiceQueryAPIEndpoint {
11708    #[serde(rename = "allowedOrigins", default)]
11709    pub allowed_origins: String,
11710    #[serde(default)]
11711    pub id: String,
11712    #[serde(rename = "openApiKeys", default)]
11713    pub open_api_keys: Vec<String>,
11714    #[serde(default)]
11715    pub roles: Vec<String>,
11716}
11717
11718/// `ServiceReplicaScalingPatchRequest` from the ClickHouse Cloud API.
11719#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11720pub struct ServiceReplicaScalingPatchRequest {
11721    #[serde(rename = "idleScaling", skip_serializing_if = "Option::is_none", default)]
11722    pub idle_scaling: Option<bool>,
11723    #[serde(rename = "idleTimeoutMinutes", skip_serializing_if = "Option::is_none", default)]
11724    pub idle_timeout_minutes: Option<f64>,
11725    #[serde(rename = "maxReplicaMemoryGb", skip_serializing_if = "Option::is_none", default)]
11726    pub max_replica_memory_gb: Option<f64>,
11727    #[serde(rename = "maxReplicas", skip_serializing_if = "Option::is_none", default)]
11728    pub max_replicas: Option<f64>,
11729    #[serde(rename = "minReplicaMemoryGb", skip_serializing_if = "Option::is_none", default)]
11730    pub min_replica_memory_gb: Option<f64>,
11731    #[serde(rename = "minReplicas", skip_serializing_if = "Option::is_none", default)]
11732    pub min_replicas: Option<f64>,
11733    #[serde(rename = "numReplicas", skip_serializing_if = "Option::is_none", default)]
11734    pub num_replicas: Option<f64>,
11735    #[serde(rename = "replicaMemoryGb", skip_serializing_if = "Option::is_none", default)]
11736    pub replica_memory_gb: Option<f64>,
11737}
11738
11739/// `ServiceScalingPatchRequest` from the ClickHouse Cloud API.
11740#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11741pub struct ServiceScalingPatchRequest {
11742    #[serde(rename = "idleScaling", skip_serializing_if = "Option::is_none", default)]
11743    pub idle_scaling: Option<bool>,
11744    #[serde(rename = "idleTimeoutMinutes", skip_serializing_if = "Option::is_none", default)]
11745    pub idle_timeout_minutes: Option<f64>,
11746    #[cfg(feature = "deprecated-fields")]
11747    #[serde(rename = "maxTotalMemoryGb", skip_serializing_if = "Option::is_none", default)]
11748    pub max_total_memory_gb: Option<f64>,
11749    #[cfg(feature = "deprecated-fields")]
11750    #[serde(rename = "minTotalMemoryGb", skip_serializing_if = "Option::is_none", default)]
11751    pub min_total_memory_gb: Option<f64>,
11752    #[serde(rename = "numReplicas", skip_serializing_if = "Option::is_none", default)]
11753    pub num_replicas: Option<f64>,
11754}
11755
11756/// `ServiceScalingPatchResponse` from the ClickHouse Cloud API.
11757#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11758pub struct ServiceScalingPatchResponse {
11759    #[serde(rename = "availablePrivateEndpointIds", default)]
11760    pub available_private_endpoint_ids: Vec<String>,
11761    #[serde(rename = "byocId", default)]
11762    pub byoc_id: String,
11763    #[serde(rename = "clickhouseVersion", default)]
11764    pub clickhouse_version: String,
11765    #[serde(rename = "complianceType", default)]
11766    pub compliance_type: ServiceScalingPatchResponseCompliancetype,
11767    #[serde(rename = "createdAt", default)]
11768    pub created_at: chrono::DateTime<chrono::Utc>,
11769    #[serde(rename = "currentScaling", default)]
11770    pub current_scaling: CurrentScaling,
11771    #[serde(rename = "dataWarehouseId", default)]
11772    pub data_warehouse_id: String,
11773    #[serde(rename = "enableCoreDumps", default)]
11774    pub enable_core_dumps: bool,
11775    #[serde(rename = "encryptionAssumedRoleIdentifier", skip_serializing_if = "Option::is_none", default)]
11776    pub encryption_assumed_role_identifier: Option<String>,
11777    #[serde(rename = "encryptionKey", skip_serializing_if = "Option::is_none", default)]
11778    pub encryption_key: Option<String>,
11779    #[serde(rename = "encryptionRoleId", default)]
11780    pub encryption_role_id: String,
11781    #[serde(default)]
11782    pub endpoints: Vec<ServiceEndpoint>,
11783    #[serde(rename = "hasTransparentDataEncryption", default)]
11784    pub has_transparent_data_encryption: bool,
11785    #[serde(rename = "iamRole", default)]
11786    pub iam_role: String,
11787    #[serde(default)]
11788    pub id: uuid::Uuid,
11789    #[serde(rename = "idleScaling", default)]
11790    pub idle_scaling: bool,
11791    #[serde(rename = "idleTimeoutMinutes", default)]
11792    pub idle_timeout_minutes: f64,
11793    #[serde(rename = "ipAccessList", default)]
11794    pub ip_access_list: Vec<IpAccessListEntry>,
11795    #[serde(rename = "isPrimary", default)]
11796    pub is_primary: bool,
11797    #[serde(rename = "isReadonly", default)]
11798    pub is_readonly: bool,
11799    #[serde(rename = "maxReplicaMemoryGb", default)]
11800    pub max_replica_memory_gb: f64,
11801    #[serde(rename = "maxReplicas", default)]
11802    pub max_replicas: f64,
11803    #[cfg(feature = "deprecated-fields")]
11804    #[serde(rename = "maxTotalMemoryGb", default)]
11805    pub max_total_memory_gb: f64,
11806    #[serde(rename = "minReplicaMemoryGb", default)]
11807    pub min_replica_memory_gb: f64,
11808    #[serde(rename = "minReplicas", default)]
11809    pub min_replicas: f64,
11810    #[cfg(feature = "deprecated-fields")]
11811    #[serde(rename = "minTotalMemoryGb", default)]
11812    pub min_total_memory_gb: f64,
11813    #[serde(default)]
11814    pub name: String,
11815    #[serde(rename = "numReplicas", default)]
11816    pub num_replicas: f64,
11817    #[serde(rename = "privateEndpointIds", default)]
11818    pub private_endpoint_ids: Vec<String>,
11819    #[serde(default)]
11820    pub profile: ServiceScalingPatchResponseProfile,
11821    #[serde(default)]
11822    pub provider: ServiceScalingPatchResponseProvider,
11823    #[serde(default)]
11824    pub region: ServiceScalingPatchResponseRegion,
11825    #[serde(rename = "releaseChannel", default)]
11826    pub release_channel: ServiceScalingPatchResponseReleasechannel,
11827    #[serde(rename = "replicaMemoryGb", default)]
11828    pub replica_memory_gb: f64,
11829    #[serde(rename = "scalingSchedule", default)]
11830    pub scaling_schedule: ScalingSchedule,
11831    #[serde(default)]
11832    pub state: ServiceScalingPatchResponseState,
11833    #[serde(default)]
11834    pub tags: Vec<ResourceTagsV1>,
11835    #[cfg(feature = "deprecated-fields")]
11836    #[serde(default)]
11837    pub tier: ServiceScalingPatchResponseTier,
11838    #[serde(rename = "transparentDataEncryptionKeyId", default)]
11839    pub transparent_data_encryption_key_id: String,
11840}
11841
11842/// `ServiceStatePatchRequest` from the ClickHouse Cloud API.
11843#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11844pub struct ServiceStatePatchRequest {
11845    #[serde(skip_serializing_if = "Option::is_none", default)]
11846    pub command: Option<ServiceStatePatchRequestCommand>,
11847}
11848
11849/// `UpgradeWindow` from the ClickHouse Cloud API.
11850#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11851pub struct UpgradeWindow {
11852    #[serde(default)]
11853    pub duration: i64,
11854    #[serde(rename = "startHourUtc", default)]
11855    pub start_hour_utc: i64,
11856    #[serde(default)]
11857    pub weekday: i64,
11858}
11859
11860/// `UpgradeWindowPutRequest` from the ClickHouse Cloud API.
11861#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11862pub struct UpgradeWindowPutRequest {
11863    #[serde(rename = "startHourUtc", default)]
11864    pub start_hour_utc: i64,
11865    #[serde(default)]
11866    pub weekday: i64,
11867}
11868
11869/// `UsageCost` from the ClickHouse Cloud API.
11870#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11871pub struct UsageCost {
11872    #[serde(default)]
11873    pub costs: Vec<UsageCostRecord>,
11874    #[serde(rename = "grandTotalCHC", default)]
11875    pub grand_total_chc: f64,
11876}
11877
11878/// `UsageCostMetrics` from the ClickHouse Cloud API.
11879#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11880pub struct UsageCostMetrics {
11881    #[serde(rename = "backupCHC", default)]
11882    pub backup_chc: f64,
11883    #[serde(rename = "computeCHC", default)]
11884    pub compute_chc: f64,
11885    #[serde(rename = "dataTransferCHC", default)]
11886    pub data_transfer_chc: f64,
11887    #[serde(rename = "initialLoadCHC", default)]
11888    pub initial_load_chc: f64,
11889    #[serde(rename = "interRegionTier1DataTransferCHC", default)]
11890    pub inter_region_tier1_data_transfer_chc: f64,
11891    #[serde(rename = "interRegionTier2DataTransferCHC", default)]
11892    pub inter_region_tier2_data_transfer_chc: f64,
11893    #[serde(rename = "interRegionTier3DataTransferCHC", default)]
11894    pub inter_region_tier3_data_transfer_chc: f64,
11895    #[serde(rename = "interRegionTier4DataTransferCHC", default)]
11896    pub inter_region_tier4_data_transfer_chc: f64,
11897    #[serde(rename = "publicDataTransferCHC", default)]
11898    pub public_data_transfer_chc: f64,
11899    #[serde(rename = "storageCHC", default)]
11900    pub storage_chc: f64,
11901}
11902
11903/// `UsageCostRecord` from the ClickHouse Cloud API.
11904#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11905pub struct UsageCostRecord {
11906    #[serde(rename = "dataWarehouseId", default)]
11907    pub data_warehouse_id: uuid::Uuid,
11908    #[serde(default)]
11909    pub date: String,
11910    #[serde(rename = "entityId", default)]
11911    pub entity_id: uuid::Uuid,
11912    #[serde(rename = "entityName", default)]
11913    pub entity_name: String,
11914    #[serde(rename = "entityType", default)]
11915    pub entity_type: UsageCostRecordEntitytype,
11916    #[serde(default)]
11917    pub locked: bool,
11918    #[serde(default)]
11919    pub metrics: UsageCostMetrics,
11920    #[serde(rename = "serviceId", skip_serializing_if = "Option::is_none", default)]
11921    pub service_id: Option<uuid::Uuid>,
11922    #[serde(rename = "totalCHC", default)]
11923    pub total_chc: f64,
11924}
11925
11926/// `pgBouncerConfig` from the ClickHouse Cloud API.
11927#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11928pub struct PgBouncerConfig {
11929}
11930
11931/// `pgConfig` from the ClickHouse Cloud API.
11932#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11933pub struct PgConfig {
11934    #[serde(default)]
11935    pub default_transaction_isolation: PgConfigDefaultTransactionIsolation,
11936    #[serde(default)]
11937    pub effective_cache_size: serde_json::Value,
11938    #[serde(default)]
11939    pub effective_io_concurrency: i64,
11940    #[serde(default)]
11941    pub idle_in_transaction_session_timeout: serde_json::Value,
11942    #[serde(default)]
11943    pub idle_session_timeout: serde_json::Value,
11944    #[serde(default)]
11945    pub lock_timeout: serde_json::Value,
11946    #[serde(default)]
11947    pub maintenance_work_mem: serde_json::Value,
11948    #[serde(default)]
11949    pub max_connections: i64,
11950    #[serde(default)]
11951    pub max_parallel_maintenance_workers: i64,
11952    #[serde(default)]
11953    pub max_parallel_workers: i64,
11954    #[serde(default)]
11955    pub max_parallel_workers_per_gather: i64,
11956    #[serde(default)]
11957    pub max_slot_wal_keep_size: serde_json::Value,
11958    #[serde(default)]
11959    pub max_wal_size: serde_json::Value,
11960    #[serde(default)]
11961    pub max_worker_processes: i64,
11962    #[serde(default)]
11963    pub min_wal_size: serde_json::Value,
11964    #[serde(default)]
11965    pub random_page_cost: f64,
11966    #[serde(default)]
11967    pub ssl_min_protocol_version: PgConfigSslMinProtocolVersion,
11968    #[serde(default)]
11969    pub statement_timeout: serde_json::Value,
11970    #[serde(default)]
11971    pub transaction_timeout: serde_json::Value,
11972    #[serde(default)]
11973    pub wal_compression: PgConfigWalCompression,
11974    #[serde(default)]
11975    pub wal_keep_size: serde_json::Value,
11976    #[serde(default)]
11977    pub wal_sender_timeout: serde_json::Value,
11978    #[serde(default)]
11979    pub work_mem: serde_json::Value,
11980}
11981
11982/// `postgresInstanceConfig` from the ClickHouse Cloud API.
11983#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11984pub struct PostgresInstanceConfig {
11985    #[serde(rename = "pgBouncerConfig")]
11986    pub pg_bouncer_config: PgBouncerConfig,
11987    #[serde(rename = "pgConfig")]
11988    pub pg_config: PgConfig,
11989}
11990
11991/// `postgresInstanceUpdateConfigResponse` from the ClickHouse Cloud API.
11992#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
11993pub struct PostgresInstanceUpdateConfigResponse {
11994    #[serde(skip_serializing_if = "Option::is_none", default)]
11995    pub message: Option<String>,
11996    #[serde(rename = "pgBouncerConfig")]
11997    pub pg_bouncer_config: PgBouncerConfig,
11998    #[serde(rename = "pgConfig")]
11999    pub pg_config: PgConfig,
12000}
12001
12002/// Standard API response wrapper.
12003#[derive(Debug, Clone, PartialEq, Default, Serialize, Deserialize)]
12004pub struct ApiResponse<T> {
12005    #[serde(skip_serializing_if = "Option::is_none", default)]
12006    pub status: Option<f64>,
12007    #[serde(skip_serializing_if = "Option::is_none", default, rename = "requestId")]
12008    pub request_id: Option<String>,
12009    pub result: Option<T>,
12010    #[serde(skip_serializing_if = "Option::is_none", default)]
12011    pub error: Option<String>,
12012}
12013
12014
12015impl Default for BackupBucket {
12016    fn default() -> Self {
12017        Self::AwsBackupBucket(AwsBackupBucket::default())
12018    }
12019}
12020
12021
12022impl Default for BackupBucketPatchRequest {
12023    fn default() -> Self {
12024        Self::AwsBackupBucketPatchRequestV1(AwsBackupBucketPatchRequestV1::default())
12025    }
12026}
12027
12028
12029impl Default for BackupBucketPostRequest {
12030    fn default() -> Self {
12031        Self::AwsBackupBucketPostRequestV1(AwsBackupBucketPostRequestV1::default())
12032    }
12033}
12034
12035
12036impl Default for BackupBucketProperties {
12037    fn default() -> Self {
12038        Self::AwsBackupBucketProperties(AwsBackupBucketProperties::default())
12039    }
12040}
12041
12042
12043impl Default for ClickStackAlertChannel {
12044    fn default() -> Self {
12045        Self::ClickStackAlertChannelEmail(ClickStackAlertChannelEmail::default())
12046    }
12047}
12048
12049
12050impl Default for ClickStackBarChartConfig {
12051    fn default() -> Self {
12052        Self::ClickStackBarBuilderChartConfig(ClickStackBarBuilderChartConfig::default())
12053    }
12054}
12055
12056
12057impl Default for ClickStackDashboardChartSeries {
12058    fn default() -> Self {
12059        Self::ClickStackTimeChartSeries(ClickStackTimeChartSeries::default())
12060    }
12061}
12062
12063
12064impl Default for ClickStackLineChartConfig {
12065    fn default() -> Self {
12066        Self::ClickStackLineBuilderChartConfig(ClickStackLineBuilderChartConfig::default())
12067    }
12068}
12069
12070
12071impl Default for ClickStackNumberChartConfig {
12072    fn default() -> Self {
12073        Self::ClickStackNumberBuilderChartConfig(ClickStackNumberBuilderChartConfig::default())
12074    }
12075}
12076
12077
12078impl Default for ClickStackPieChartConfig {
12079    fn default() -> Self {
12080        Self::ClickStackPieBuilderChartConfig(ClickStackPieBuilderChartConfig::default())
12081    }
12082}
12083
12084
12085impl Default for ClickStackSource {
12086    fn default() -> Self {
12087        Self::ClickStackLogSource(ClickStackLogSource::default())
12088    }
12089}
12090
12091
12092impl Default for ClickStackTableChartConfig {
12093    fn default() -> Self {
12094        Self::ClickStackTableBuilderChartConfig(ClickStackTableBuilderChartConfig::default())
12095    }
12096}
12097
12098
12099impl Default for ClickStackTileConfig {
12100    fn default() -> Self {
12101        Self::ClickStackLineChartConfig(ClickStackLineChartConfig::default())
12102    }
12103}
12104
12105
12106impl Default for ClickStackWebhook {
12107    fn default() -> Self {
12108        Self::ClickStackSlackWebhook(ClickStackSlackWebhook::default())
12109    }
12110}