fakecloud_cloudfront/
model.rs

1//! Serde-modeled CloudFront payload types.
2//!
3//! CloudFront uses XML on the wire with deeply nested optional fields. We
4//! define typed structs that round-trip via `quick-xml` + serde so a
5//! `DistributionConfig` parsed from a `CreateDistribution` body can be
6//! emitted byte-equivalent in a later `GetDistributionConfig`. Everything
7//! that AWS treats as optional is `Option<_>`; lists keep the AWS
8//! `Quantity`/`Items` envelope so SDK readers see the same shape.
9
10use serde::{Deserialize, Serialize};
11
12fn skip_if_none<T>(x: &Option<T>) -> bool {
13    x.is_none()
14}
15
16// ─── DistributionConfig ───────────────────────────────────────────────
17
18#[derive(Debug, Clone, Serialize, Deserialize, Default)]
19#[serde(rename_all = "PascalCase")]
20pub struct DistributionConfig {
21    pub caller_reference: String,
22    #[serde(default, skip_serializing_if = "skip_if_none")]
23    pub aliases: Option<Aliases>,
24    #[serde(default, skip_serializing_if = "skip_if_none")]
25    pub default_root_object: Option<String>,
26    pub origins: Origins,
27    #[serde(default, skip_serializing_if = "skip_if_none")]
28    pub origin_groups: Option<OriginGroups>,
29    pub default_cache_behavior: DefaultCacheBehavior,
30    #[serde(default, skip_serializing_if = "skip_if_none")]
31    pub cache_behaviors: Option<CacheBehaviors>,
32    #[serde(default, skip_serializing_if = "skip_if_none")]
33    pub custom_error_responses: Option<CustomErrorResponses>,
34    pub comment: String,
35    #[serde(default, skip_serializing_if = "skip_if_none")]
36    pub logging: Option<LoggingConfig>,
37    #[serde(default, skip_serializing_if = "skip_if_none")]
38    pub price_class: Option<String>,
39    pub enabled: bool,
40    #[serde(default, skip_serializing_if = "skip_if_none")]
41    pub viewer_certificate: Option<ViewerCertificate>,
42    #[serde(default, skip_serializing_if = "skip_if_none")]
43    pub restrictions: Option<Restrictions>,
44    // AWS spells this `WebACLId` (upper-case ACL). The default PascalCase
45    // rule would emit `WebAclId`, which drops the field on parse from real
46    // SDK requests and mis-names it on the wire. Pin the exact name.
47    #[serde(default, rename = "WebACLId", skip_serializing_if = "skip_if_none")]
48    pub web_acl_id: Option<String>,
49    #[serde(default, skip_serializing_if = "skip_if_none")]
50    pub http_version: Option<String>,
51    #[serde(default, skip_serializing_if = "skip_if_none")]
52    pub is_ipv6_enabled: Option<bool>,
53    #[serde(default, skip_serializing_if = "skip_if_none")]
54    pub continuous_deployment_policy_id: Option<String>,
55    #[serde(default, skip_serializing_if = "skip_if_none")]
56    pub staging: Option<bool>,
57    #[serde(default, skip_serializing_if = "skip_if_none")]
58    pub anycast_ip_list_id: Option<String>,
59    #[serde(default, skip_serializing_if = "skip_if_none")]
60    pub tenant_config: Option<TenantConfig>,
61    #[serde(default, skip_serializing_if = "skip_if_none")]
62    pub connection_mode: Option<String>,
63}
64
65#[derive(Debug, Clone, Serialize, Deserialize, Default)]
66#[serde(rename_all = "PascalCase")]
67pub struct Aliases {
68    pub quantity: i32,
69    #[serde(default, skip_serializing_if = "skip_if_none")]
70    pub items: Option<AliasItems>,
71}
72
73#[derive(Debug, Clone, Serialize, Deserialize, Default)]
74#[serde(rename_all = "PascalCase")]
75pub struct AliasItems {
76    #[serde(default, rename = "CNAME")]
77    pub cname: Vec<String>,
78}
79
80#[derive(Debug, Clone, Serialize, Deserialize, Default)]
81#[serde(rename_all = "PascalCase")]
82pub struct Origins {
83    pub quantity: i32,
84    #[serde(default, skip_serializing_if = "skip_if_none")]
85    pub items: Option<OriginItems>,
86}
87
88#[derive(Debug, Clone, Serialize, Deserialize, Default)]
89#[serde(rename_all = "PascalCase")]
90pub struct OriginItems {
91    #[serde(default)]
92    pub origin: Vec<Origin>,
93}
94
95#[derive(Debug, Clone, Serialize, Deserialize, Default)]
96#[serde(rename_all = "PascalCase")]
97pub struct Origin {
98    pub id: String,
99    pub domain_name: String,
100    #[serde(default, skip_serializing_if = "skip_if_none")]
101    pub origin_path: Option<String>,
102    #[serde(default, skip_serializing_if = "skip_if_none")]
103    pub custom_headers: Option<CustomHeaders>,
104    #[serde(default, skip_serializing_if = "skip_if_none")]
105    pub s3_origin_config: Option<S3OriginConfig>,
106    #[serde(default, skip_serializing_if = "skip_if_none")]
107    pub custom_origin_config: Option<CustomOriginConfig>,
108    #[serde(default, skip_serializing_if = "skip_if_none")]
109    pub vpc_origin_config: Option<VpcOriginConfig>,
110    #[serde(default, skip_serializing_if = "skip_if_none")]
111    pub connection_attempts: Option<i32>,
112    #[serde(default, skip_serializing_if = "skip_if_none")]
113    pub connection_timeout: Option<i32>,
114    #[serde(default, skip_serializing_if = "skip_if_none")]
115    pub origin_shield: Option<OriginShield>,
116    #[serde(default, skip_serializing_if = "skip_if_none")]
117    pub origin_access_control_id: Option<String>,
118    #[serde(default, skip_serializing_if = "skip_if_none")]
119    pub response_completion_timeout: Option<i32>,
120}
121
122#[derive(Debug, Clone, Serialize, Deserialize, Default)]
123#[serde(rename_all = "PascalCase")]
124pub struct CustomHeaders {
125    pub quantity: i32,
126    #[serde(default, skip_serializing_if = "skip_if_none")]
127    pub items: Option<CustomHeaderItems>,
128}
129
130#[derive(Debug, Clone, Serialize, Deserialize, Default)]
131#[serde(rename_all = "PascalCase")]
132pub struct CustomHeaderItems {
133    #[serde(default)]
134    pub origin_custom_header: Vec<OriginCustomHeader>,
135}
136
137#[derive(Debug, Clone, Serialize, Deserialize, Default)]
138#[serde(rename_all = "PascalCase")]
139pub struct OriginCustomHeader {
140    pub header_name: String,
141    pub header_value: String,
142}
143
144#[derive(Debug, Clone, Serialize, Deserialize, Default)]
145#[serde(rename_all = "PascalCase")]
146pub struct S3OriginConfig {
147    pub origin_access_identity: String,
148}
149
150#[derive(Debug, Clone, Serialize, Deserialize, Default)]
151#[serde(rename_all = "PascalCase")]
152pub struct CustomOriginConfig {
153    // AWS spells these HTTPPort / HTTPSPort (not the PascalCase HttpPort), so a
154    // real SDK's CreateDistribution with a custom origin round-trips. Matches
155    // the casing already used in extras.rs.
156    #[serde(rename = "HTTPPort")]
157    pub http_port: i32,
158    #[serde(rename = "HTTPSPort")]
159    pub https_port: i32,
160    pub origin_protocol_policy: String,
161    #[serde(default, skip_serializing_if = "skip_if_none")]
162    pub origin_ssl_protocols: Option<OriginSslProtocols>,
163    #[serde(default, skip_serializing_if = "skip_if_none")]
164    pub origin_read_timeout: Option<i32>,
165    #[serde(default, skip_serializing_if = "skip_if_none")]
166    pub origin_keepalive_timeout: Option<i32>,
167}
168
169#[derive(Debug, Clone, Serialize, Deserialize, Default)]
170#[serde(rename_all = "PascalCase")]
171pub struct OriginSslProtocols {
172    pub quantity: i32,
173    pub items: SslProtocolItems,
174}
175
176#[derive(Debug, Clone, Serialize, Deserialize, Default)]
177#[serde(rename_all = "PascalCase")]
178pub struct SslProtocolItems {
179    #[serde(default, rename = "SslProtocol")]
180    pub ssl_protocol: Vec<String>,
181}
182
183#[derive(Debug, Clone, Serialize, Deserialize, Default)]
184#[serde(rename_all = "PascalCase")]
185pub struct VpcOriginConfig {
186    pub vpc_origin_id: String,
187    #[serde(default, skip_serializing_if = "skip_if_none")]
188    pub origin_read_timeout: Option<i32>,
189    #[serde(default, skip_serializing_if = "skip_if_none")]
190    pub origin_keepalive_timeout: Option<i32>,
191}
192
193#[derive(Debug, Clone, Serialize, Deserialize, Default)]
194#[serde(rename_all = "PascalCase")]
195pub struct OriginShield {
196    pub enabled: bool,
197    #[serde(default, skip_serializing_if = "skip_if_none")]
198    pub origin_shield_region: Option<String>,
199}
200
201#[derive(Debug, Clone, Serialize, Deserialize, Default)]
202#[serde(rename_all = "PascalCase")]
203pub struct OriginGroups {
204    pub quantity: i32,
205    #[serde(default, skip_serializing_if = "skip_if_none")]
206    pub items: Option<OriginGroupItems>,
207}
208
209#[derive(Debug, Clone, Serialize, Deserialize, Default)]
210#[serde(rename_all = "PascalCase")]
211pub struct OriginGroupItems {
212    #[serde(default)]
213    pub origin_group: Vec<OriginGroup>,
214}
215
216#[derive(Debug, Clone, Serialize, Deserialize, Default)]
217#[serde(rename_all = "PascalCase")]
218pub struct OriginGroup {
219    pub id: String,
220    pub failover_criteria: OriginGroupFailoverCriteria,
221    pub members: OriginGroupMembers,
222    #[serde(default, skip_serializing_if = "skip_if_none")]
223    pub selection_criteria: Option<String>,
224}
225
226#[derive(Debug, Clone, Serialize, Deserialize, Default)]
227#[serde(rename_all = "PascalCase")]
228pub struct OriginGroupFailoverCriteria {
229    pub status_codes: StatusCodes,
230}
231
232#[derive(Debug, Clone, Serialize, Deserialize, Default)]
233#[serde(rename_all = "PascalCase")]
234pub struct StatusCodes {
235    pub quantity: i32,
236    pub items: StatusCodeItems,
237}
238
239#[derive(Debug, Clone, Serialize, Deserialize, Default)]
240#[serde(rename_all = "PascalCase")]
241pub struct StatusCodeItems {
242    #[serde(default, rename = "StatusCode")]
243    pub status_code: Vec<i32>,
244}
245
246#[derive(Debug, Clone, Serialize, Deserialize, Default)]
247#[serde(rename_all = "PascalCase")]
248pub struct OriginGroupMembers {
249    pub quantity: i32,
250    pub items: OriginGroupMemberItems,
251}
252
253#[derive(Debug, Clone, Serialize, Deserialize, Default)]
254#[serde(rename_all = "PascalCase")]
255pub struct OriginGroupMemberItems {
256    #[serde(default)]
257    pub origin_group_member: Vec<OriginGroupMember>,
258}
259
260#[derive(Debug, Clone, Serialize, Deserialize, Default)]
261#[serde(rename_all = "PascalCase")]
262pub struct OriginGroupMember {
263    pub origin_id: String,
264}
265
266#[derive(Debug, Clone, Serialize, Deserialize, Default)]
267#[serde(rename_all = "PascalCase")]
268pub struct DefaultCacheBehavior {
269    pub target_origin_id: String,
270    #[serde(default, skip_serializing_if = "skip_if_none")]
271    pub trusted_signers: Option<TrustedSigners>,
272    #[serde(default, skip_serializing_if = "skip_if_none")]
273    pub trusted_key_groups: Option<TrustedKeyGroups>,
274    pub viewer_protocol_policy: String,
275    #[serde(default, skip_serializing_if = "skip_if_none")]
276    pub allowed_methods: Option<AllowedMethods>,
277    #[serde(default, skip_serializing_if = "skip_if_none")]
278    pub smooth_streaming: Option<bool>,
279    #[serde(default, skip_serializing_if = "skip_if_none")]
280    pub compress: Option<bool>,
281    #[serde(default, skip_serializing_if = "skip_if_none")]
282    pub lambda_function_associations: Option<LambdaFunctionAssociations>,
283    #[serde(default, skip_serializing_if = "skip_if_none")]
284    pub function_associations: Option<FunctionAssociations>,
285    #[serde(default, skip_serializing_if = "skip_if_none")]
286    pub field_level_encryption_id: Option<String>,
287    #[serde(default, skip_serializing_if = "skip_if_none")]
288    pub realtime_log_config_arn: Option<String>,
289    #[serde(default, skip_serializing_if = "skip_if_none")]
290    pub cache_policy_id: Option<String>,
291    #[serde(default, skip_serializing_if = "skip_if_none")]
292    pub origin_request_policy_id: Option<String>,
293    #[serde(default, skip_serializing_if = "skip_if_none")]
294    pub response_headers_policy_id: Option<String>,
295    #[serde(default, skip_serializing_if = "skip_if_none")]
296    pub grpc_config: Option<GrpcConfig>,
297    #[serde(default, skip_serializing_if = "skip_if_none")]
298    pub forwarded_values: Option<ForwardedValues>,
299    #[serde(default, skip_serializing_if = "skip_if_none")]
300    pub min_ttl: Option<i64>,
301    #[serde(default, skip_serializing_if = "skip_if_none")]
302    pub default_ttl: Option<i64>,
303    #[serde(default, skip_serializing_if = "skip_if_none")]
304    pub max_ttl: Option<i64>,
305}
306
307#[derive(Debug, Clone, Serialize, Deserialize, Default)]
308#[serde(rename_all = "PascalCase")]
309pub struct TrustedSigners {
310    pub enabled: bool,
311    pub quantity: i32,
312    #[serde(default, skip_serializing_if = "skip_if_none")]
313    pub items: Option<AwsAccountNumberList>,
314}
315
316#[derive(Debug, Clone, Serialize, Deserialize, Default)]
317#[serde(rename_all = "PascalCase")]
318pub struct AwsAccountNumberList {
319    #[serde(default, rename = "AwsAccountNumber")]
320    pub aws_account_number: Vec<String>,
321}
322
323#[derive(Debug, Clone, Serialize, Deserialize, Default)]
324#[serde(rename_all = "PascalCase")]
325pub struct TrustedKeyGroups {
326    pub enabled: bool,
327    pub quantity: i32,
328    #[serde(default, skip_serializing_if = "skip_if_none")]
329    pub items: Option<TrustedKeyGroupIdList>,
330}
331
332#[derive(Debug, Clone, Serialize, Deserialize, Default)]
333#[serde(rename_all = "PascalCase")]
334pub struct TrustedKeyGroupIdList {
335    #[serde(default, rename = "KeyGroup")]
336    pub key_group: Vec<String>,
337}
338
339#[derive(Debug, Clone, Serialize, Deserialize, Default)]
340#[serde(rename_all = "PascalCase")]
341pub struct AllowedMethods {
342    pub quantity: i32,
343    pub items: MethodList,
344    #[serde(default, skip_serializing_if = "skip_if_none")]
345    pub cached_methods: Option<CachedMethods>,
346}
347
348#[derive(Debug, Clone, Serialize, Deserialize, Default)]
349#[serde(rename_all = "PascalCase")]
350pub struct MethodList {
351    #[serde(default, rename = "Method")]
352    pub method: Vec<String>,
353}
354
355#[derive(Debug, Clone, Serialize, Deserialize, Default)]
356#[serde(rename_all = "PascalCase")]
357pub struct CachedMethods {
358    pub quantity: i32,
359    pub items: MethodList,
360}
361
362#[derive(Debug, Clone, Serialize, Deserialize, Default)]
363#[serde(rename_all = "PascalCase")]
364pub struct LambdaFunctionAssociations {
365    pub quantity: i32,
366    #[serde(default, skip_serializing_if = "skip_if_none")]
367    pub items: Option<LambdaFunctionAssociationItems>,
368}
369
370#[derive(Debug, Clone, Serialize, Deserialize, Default)]
371#[serde(rename_all = "PascalCase")]
372pub struct LambdaFunctionAssociationItems {
373    #[serde(default)]
374    pub lambda_function_association: Vec<LambdaFunctionAssociation>,
375}
376
377#[derive(Debug, Clone, Serialize, Deserialize, Default)]
378#[serde(rename_all = "PascalCase")]
379pub struct LambdaFunctionAssociation {
380    pub lambda_function_arn: String,
381    pub event_type: String,
382    #[serde(default, skip_serializing_if = "skip_if_none")]
383    pub include_body: Option<bool>,
384}
385
386#[derive(Debug, Clone, Serialize, Deserialize, Default)]
387#[serde(rename_all = "PascalCase")]
388pub struct FunctionAssociations {
389    pub quantity: i32,
390    #[serde(default, skip_serializing_if = "skip_if_none")]
391    pub items: Option<FunctionAssociationItems>,
392}
393
394#[derive(Debug, Clone, Serialize, Deserialize, Default)]
395#[serde(rename_all = "PascalCase")]
396pub struct FunctionAssociationItems {
397    #[serde(default)]
398    pub function_association: Vec<FunctionAssociation>,
399}
400
401#[derive(Debug, Clone, Serialize, Deserialize, Default)]
402#[serde(rename_all = "PascalCase")]
403pub struct FunctionAssociation {
404    pub function_arn: String,
405    pub event_type: String,
406}
407
408#[derive(Debug, Clone, Serialize, Deserialize, Default)]
409#[serde(rename_all = "PascalCase")]
410pub struct GrpcConfig {
411    pub enabled: bool,
412}
413
414#[derive(Debug, Clone, Serialize, Deserialize, Default)]
415#[serde(rename_all = "PascalCase")]
416pub struct ForwardedValues {
417    pub query_string: bool,
418    pub cookies: CookiePreference,
419    #[serde(default, skip_serializing_if = "skip_if_none")]
420    pub headers: Option<Headers>,
421    #[serde(default, skip_serializing_if = "skip_if_none")]
422    pub query_string_cache_keys: Option<QueryStringCacheKeys>,
423}
424
425#[derive(Debug, Clone, Serialize, Deserialize, Default)]
426#[serde(rename_all = "PascalCase")]
427pub struct CookiePreference {
428    pub forward: String,
429    #[serde(default, skip_serializing_if = "skip_if_none")]
430    pub whitelisted_names: Option<CookieNames>,
431}
432
433#[derive(Debug, Clone, Serialize, Deserialize, Default)]
434#[serde(rename_all = "PascalCase")]
435pub struct CookieNames {
436    pub quantity: i32,
437    #[serde(default, skip_serializing_if = "skip_if_none")]
438    pub items: Option<CookieNameList>,
439}
440
441#[derive(Debug, Clone, Serialize, Deserialize, Default)]
442#[serde(rename_all = "PascalCase")]
443pub struct CookieNameList {
444    #[serde(default, rename = "Name")]
445    pub name: Vec<String>,
446}
447
448#[derive(Debug, Clone, Serialize, Deserialize, Default)]
449#[serde(rename_all = "PascalCase")]
450pub struct Headers {
451    pub quantity: i32,
452    #[serde(default, skip_serializing_if = "skip_if_none")]
453    pub items: Option<HeaderList>,
454}
455
456#[derive(Debug, Clone, Serialize, Deserialize, Default)]
457#[serde(rename_all = "PascalCase")]
458pub struct HeaderList {
459    #[serde(default, rename = "Name")]
460    pub name: Vec<String>,
461}
462
463#[derive(Debug, Clone, Serialize, Deserialize, Default)]
464#[serde(rename_all = "PascalCase")]
465pub struct QueryStringCacheKeys {
466    pub quantity: i32,
467    #[serde(default, skip_serializing_if = "skip_if_none")]
468    pub items: Option<QueryStringCacheKeyList>,
469}
470
471#[derive(Debug, Clone, Serialize, Deserialize, Default)]
472#[serde(rename_all = "PascalCase")]
473pub struct QueryStringCacheKeyList {
474    #[serde(default, rename = "Name")]
475    pub name: Vec<String>,
476}
477
478#[derive(Debug, Clone, Serialize, Deserialize, Default)]
479#[serde(rename_all = "PascalCase")]
480pub struct CacheBehaviors {
481    pub quantity: i32,
482    #[serde(default, skip_serializing_if = "skip_if_none")]
483    pub items: Option<CacheBehaviorItems>,
484}
485
486#[derive(Debug, Clone, Serialize, Deserialize, Default)]
487#[serde(rename_all = "PascalCase")]
488pub struct CacheBehaviorItems {
489    #[serde(default)]
490    pub cache_behavior: Vec<CacheBehavior>,
491}
492
493#[derive(Debug, Clone, Serialize, Deserialize, Default)]
494#[serde(rename_all = "PascalCase")]
495pub struct CacheBehavior {
496    pub path_pattern: String,
497    pub target_origin_id: String,
498    #[serde(default, skip_serializing_if = "skip_if_none")]
499    pub trusted_signers: Option<TrustedSigners>,
500    #[serde(default, skip_serializing_if = "skip_if_none")]
501    pub trusted_key_groups: Option<TrustedKeyGroups>,
502    pub viewer_protocol_policy: String,
503    #[serde(default, skip_serializing_if = "skip_if_none")]
504    pub allowed_methods: Option<AllowedMethods>,
505    #[serde(default, skip_serializing_if = "skip_if_none")]
506    pub smooth_streaming: Option<bool>,
507    #[serde(default, skip_serializing_if = "skip_if_none")]
508    pub compress: Option<bool>,
509    #[serde(default, skip_serializing_if = "skip_if_none")]
510    pub lambda_function_associations: Option<LambdaFunctionAssociations>,
511    #[serde(default, skip_serializing_if = "skip_if_none")]
512    pub function_associations: Option<FunctionAssociations>,
513    #[serde(default, skip_serializing_if = "skip_if_none")]
514    pub field_level_encryption_id: Option<String>,
515    #[serde(default, skip_serializing_if = "skip_if_none")]
516    pub realtime_log_config_arn: Option<String>,
517    #[serde(default, skip_serializing_if = "skip_if_none")]
518    pub cache_policy_id: Option<String>,
519    #[serde(default, skip_serializing_if = "skip_if_none")]
520    pub origin_request_policy_id: Option<String>,
521    #[serde(default, skip_serializing_if = "skip_if_none")]
522    pub response_headers_policy_id: Option<String>,
523    #[serde(default, skip_serializing_if = "skip_if_none")]
524    pub grpc_config: Option<GrpcConfig>,
525    #[serde(default, skip_serializing_if = "skip_if_none")]
526    pub forwarded_values: Option<ForwardedValues>,
527    #[serde(default, skip_serializing_if = "skip_if_none")]
528    pub min_ttl: Option<i64>,
529    #[serde(default, skip_serializing_if = "skip_if_none")]
530    pub default_ttl: Option<i64>,
531    #[serde(default, skip_serializing_if = "skip_if_none")]
532    pub max_ttl: Option<i64>,
533}
534
535#[derive(Debug, Clone, Serialize, Deserialize, Default)]
536#[serde(rename_all = "PascalCase")]
537pub struct CustomErrorResponses {
538    pub quantity: i32,
539    #[serde(default, skip_serializing_if = "skip_if_none")]
540    pub items: Option<CustomErrorResponseItems>,
541}
542
543#[derive(Debug, Clone, Serialize, Deserialize, Default)]
544#[serde(rename_all = "PascalCase")]
545pub struct CustomErrorResponseItems {
546    #[serde(default)]
547    pub custom_error_response: Vec<CustomErrorResponse>,
548}
549
550#[derive(Debug, Clone, Serialize, Deserialize, Default)]
551#[serde(rename_all = "PascalCase")]
552pub struct CustomErrorResponse {
553    pub error_code: i32,
554    #[serde(default, skip_serializing_if = "skip_if_none")]
555    pub response_page_path: Option<String>,
556    #[serde(default, skip_serializing_if = "skip_if_none")]
557    pub response_code: Option<String>,
558    #[serde(default, skip_serializing_if = "skip_if_none")]
559    pub error_caching_min_ttl: Option<i64>,
560}
561
562#[derive(Debug, Clone, Serialize, Deserialize, Default)]
563#[serde(rename_all = "PascalCase")]
564pub struct LoggingConfig {
565    pub enabled: bool,
566    pub include_cookies: bool,
567    pub bucket: String,
568    pub prefix: String,
569}
570
571#[derive(Debug, Clone, Serialize, Deserialize, Default)]
572#[serde(rename_all = "PascalCase")]
573pub struct ViewerCertificate {
574    #[serde(default, skip_serializing_if = "skip_if_none")]
575    pub cloud_front_default_certificate: Option<bool>,
576    #[serde(default, skip_serializing_if = "skip_if_none")]
577    pub iam_certificate_id: Option<String>,
578    #[serde(default, skip_serializing_if = "skip_if_none")]
579    pub acm_certificate_arn: Option<String>,
580    #[serde(default, skip_serializing_if = "skip_if_none")]
581    pub ssl_support_method: Option<String>,
582    #[serde(default, skip_serializing_if = "skip_if_none")]
583    pub minimum_protocol_version: Option<String>,
584    #[serde(default, skip_serializing_if = "skip_if_none")]
585    pub certificate: Option<String>,
586    #[serde(default, skip_serializing_if = "skip_if_none")]
587    pub certificate_source: Option<String>,
588}
589
590#[derive(Debug, Clone, Serialize, Deserialize, Default)]
591#[serde(rename_all = "PascalCase")]
592pub struct Restrictions {
593    pub geo_restriction: GeoRestriction,
594}
595
596#[derive(Debug, Clone, Serialize, Deserialize, Default)]
597#[serde(rename_all = "PascalCase")]
598pub struct GeoRestriction {
599    pub restriction_type: String,
600    pub quantity: i32,
601    #[serde(default, skip_serializing_if = "skip_if_none")]
602    pub items: Option<LocationList>,
603}
604
605#[derive(Debug, Clone, Serialize, Deserialize, Default)]
606#[serde(rename_all = "PascalCase")]
607pub struct LocationList {
608    #[serde(default, rename = "Location")]
609    pub location: Vec<String>,
610}
611
612#[derive(Debug, Clone, Serialize, Deserialize, Default)]
613#[serde(rename_all = "PascalCase")]
614pub struct TenantConfig {
615    #[serde(default, skip_serializing_if = "skip_if_none")]
616    pub parameter_definitions: Option<ParameterDefinitions>,
617}
618
619#[derive(Debug, Clone, Serialize, Deserialize, Default)]
620#[serde(rename_all = "PascalCase")]
621pub struct ParameterDefinitions {
622    #[serde(default, rename = "ParameterDefinition")]
623    pub parameter_definition: Vec<ParameterDefinition>,
624}
625
626#[derive(Debug, Clone, Serialize, Deserialize, Default)]
627#[serde(rename_all = "PascalCase")]
628pub struct ParameterDefinition {
629    pub name: String,
630    pub definition: ParameterDefinitionSchema,
631}
632
633#[derive(Debug, Clone, Serialize, Deserialize, Default)]
634#[serde(rename_all = "PascalCase")]
635pub struct ParameterDefinitionSchema {
636    #[serde(default, skip_serializing_if = "skip_if_none")]
637    pub string_schema: Option<StringSchemaConfig>,
638}
639
640#[derive(Debug, Clone, Serialize, Deserialize, Default)]
641#[serde(rename_all = "PascalCase")]
642pub struct StringSchemaConfig {
643    pub required: bool,
644    #[serde(default, skip_serializing_if = "skip_if_none")]
645    pub comment: Option<String>,
646    #[serde(default, skip_serializing_if = "skip_if_none")]
647    pub default_value: Option<String>,
648}
649
650// ─── Tags ─────────────────────────────────────────────────────────────
651
652#[derive(Debug, Clone, Serialize, Deserialize, Default)]
653#[serde(rename_all = "PascalCase")]
654pub struct Tags {
655    #[serde(default, skip_serializing_if = "skip_if_none")]
656    pub items: Option<TagList>,
657}
658
659#[derive(Debug, Clone, Serialize, Deserialize, Default)]
660#[serde(rename_all = "PascalCase")]
661pub struct TagList {
662    #[serde(default, rename = "Tag")]
663    pub tag: Vec<Tag>,
664}
665
666#[derive(Debug, Clone, Serialize, Deserialize, Default)]
667#[serde(rename_all = "PascalCase")]
668pub struct Tag {
669    pub key: String,
670    #[serde(default, skip_serializing_if = "skip_if_none")]
671    pub value: Option<String>,
672}
673
674#[derive(Debug, Clone, Serialize, Deserialize, Default)]
675#[serde(rename_all = "PascalCase")]
676pub struct TagKeys {
677    #[serde(default, skip_serializing_if = "skip_if_none")]
678    pub items: Option<TagKeyList>,
679}
680
681#[derive(Debug, Clone, Serialize, Deserialize, Default)]
682#[serde(rename_all = "PascalCase")]
683pub struct TagKeyList {
684    #[serde(default, rename = "Key")]
685    pub key: Vec<String>,
686}
687
688// ─── Distribution + Wrappers ─────────────────────────────────────────
689
690#[derive(Debug, Clone, Serialize, Deserialize, Default)]
691#[serde(rename_all = "PascalCase")]
692pub struct DistributionConfigWithTags {
693    pub distribution_config: DistributionConfig,
694    pub tags: Tags,
695}
696
697// ─── Invalidation ─────────────────────────────────────────────────────
698
699#[derive(Debug, Clone, Serialize, Deserialize, Default)]
700#[serde(rename_all = "PascalCase")]
701pub struct InvalidationBatch {
702    pub paths: Paths,
703    pub caller_reference: String,
704}
705
706#[derive(Debug, Clone, Serialize, Deserialize, Default)]
707#[serde(rename_all = "PascalCase")]
708pub struct Paths {
709    pub quantity: i32,
710    #[serde(default, skip_serializing_if = "skip_if_none")]
711    pub items: Option<PathList>,
712}
713
714#[derive(Debug, Clone, Serialize, Deserialize, Default)]
715#[serde(rename_all = "PascalCase")]
716pub struct PathList {
717    #[serde(default, rename = "Path")]
718    pub path: Vec<String>,
719}
fakecloud_cloudfront/model.rs

fakecloud_cloudfront/
model.rs
