Skip to main content

winterbaume_workspacesweb/
model.rs

1//! Auto-generated types from Smithy models.
2//! Do not edit manually. Regenerate with:
3//!   smithy-codegen gen-serializers winterbaume-workspacesweb
4
5#![allow(non_camel_case_types, clippy::upper_case_acronyms, dead_code)]
6
7use serde::{Deserialize, Serialize};
8
9#[derive(Debug, Clone, Default, Deserialize, Serialize)]
10pub struct AssociateBrowserSettingsRequest {
11    #[serde(rename = "browserSettingsArn")]
12    #[serde(default)]
13    pub browser_settings_arn: String,
14    #[serde(rename = "portalArn")]
15    #[serde(default)]
16    pub portal_arn: String,
17}
18
19#[derive(Debug, Clone, Default, Deserialize, Serialize)]
20pub struct AssociateBrowserSettingsResponse {
21    #[serde(rename = "browserSettingsArn")]
22    #[serde(default)]
23    #[serde(skip_serializing_if = "Option::is_none")]
24    pub browser_settings_arn: Option<String>,
25    #[serde(rename = "portalArn")]
26    #[serde(default)]
27    #[serde(skip_serializing_if = "Option::is_none")]
28    pub portal_arn: Option<String>,
29}
30
31#[derive(Debug, Clone, Default, Deserialize, Serialize)]
32pub struct AssociateDataProtectionSettingsRequest {
33    #[serde(rename = "dataProtectionSettingsArn")]
34    #[serde(default)]
35    pub data_protection_settings_arn: String,
36    #[serde(rename = "portalArn")]
37    #[serde(default)]
38    pub portal_arn: String,
39}
40
41#[derive(Debug, Clone, Default, Deserialize, Serialize)]
42pub struct AssociateDataProtectionSettingsResponse {
43    #[serde(rename = "dataProtectionSettingsArn")]
44    #[serde(default)]
45    #[serde(skip_serializing_if = "Option::is_none")]
46    pub data_protection_settings_arn: Option<String>,
47    #[serde(rename = "portalArn")]
48    #[serde(default)]
49    #[serde(skip_serializing_if = "Option::is_none")]
50    pub portal_arn: Option<String>,
51}
52
53#[derive(Debug, Clone, Default, Deserialize, Serialize)]
54pub struct AssociateIpAccessSettingsRequest {
55    #[serde(rename = "ipAccessSettingsArn")]
56    #[serde(default)]
57    pub ip_access_settings_arn: String,
58    #[serde(rename = "portalArn")]
59    #[serde(default)]
60    pub portal_arn: String,
61}
62
63#[derive(Debug, Clone, Default, Deserialize, Serialize)]
64pub struct AssociateIpAccessSettingsResponse {
65    #[serde(rename = "ipAccessSettingsArn")]
66    #[serde(default)]
67    #[serde(skip_serializing_if = "Option::is_none")]
68    pub ip_access_settings_arn: Option<String>,
69    #[serde(rename = "portalArn")]
70    #[serde(default)]
71    #[serde(skip_serializing_if = "Option::is_none")]
72    pub portal_arn: Option<String>,
73}
74
75#[derive(Debug, Clone, Default, Deserialize, Serialize)]
76pub struct AssociateNetworkSettingsRequest {
77    #[serde(rename = "networkSettingsArn")]
78    #[serde(default)]
79    pub network_settings_arn: String,
80    #[serde(rename = "portalArn")]
81    #[serde(default)]
82    pub portal_arn: String,
83}
84
85#[derive(Debug, Clone, Default, Deserialize, Serialize)]
86pub struct AssociateNetworkSettingsResponse {
87    #[serde(rename = "networkSettingsArn")]
88    #[serde(default)]
89    #[serde(skip_serializing_if = "Option::is_none")]
90    pub network_settings_arn: Option<String>,
91    #[serde(rename = "portalArn")]
92    #[serde(default)]
93    #[serde(skip_serializing_if = "Option::is_none")]
94    pub portal_arn: Option<String>,
95}
96
97#[derive(Debug, Clone, Default, Deserialize, Serialize)]
98pub struct AssociateSessionLoggerRequest {
99    #[serde(rename = "portalArn")]
100    #[serde(default)]
101    pub portal_arn: String,
102    #[serde(rename = "sessionLoggerArn")]
103    #[serde(default)]
104    pub session_logger_arn: String,
105}
106
107#[derive(Debug, Clone, Default, Deserialize, Serialize)]
108pub struct AssociateSessionLoggerResponse {
109    #[serde(rename = "portalArn")]
110    #[serde(default)]
111    #[serde(skip_serializing_if = "Option::is_none")]
112    pub portal_arn: Option<String>,
113    #[serde(rename = "sessionLoggerArn")]
114    #[serde(default)]
115    #[serde(skip_serializing_if = "Option::is_none")]
116    pub session_logger_arn: Option<String>,
117}
118
119#[derive(Debug, Clone, Default, Deserialize, Serialize)]
120pub struct AssociateTrustStoreRequest {
121    #[serde(rename = "portalArn")]
122    #[serde(default)]
123    pub portal_arn: String,
124    #[serde(rename = "trustStoreArn")]
125    #[serde(default)]
126    pub trust_store_arn: String,
127}
128
129#[derive(Debug, Clone, Default, Deserialize, Serialize)]
130pub struct AssociateTrustStoreResponse {
131    #[serde(rename = "portalArn")]
132    #[serde(default)]
133    #[serde(skip_serializing_if = "Option::is_none")]
134    pub portal_arn: Option<String>,
135    #[serde(rename = "trustStoreArn")]
136    #[serde(default)]
137    #[serde(skip_serializing_if = "Option::is_none")]
138    pub trust_store_arn: Option<String>,
139}
140
141#[derive(Debug, Clone, Default, Deserialize, Serialize)]
142pub struct AssociateUserAccessLoggingSettingsRequest {
143    #[serde(rename = "portalArn")]
144    #[serde(default)]
145    pub portal_arn: String,
146    #[serde(rename = "userAccessLoggingSettingsArn")]
147    #[serde(default)]
148    pub user_access_logging_settings_arn: String,
149}
150
151#[derive(Debug, Clone, Default, Deserialize, Serialize)]
152pub struct AssociateUserAccessLoggingSettingsResponse {
153    #[serde(rename = "portalArn")]
154    #[serde(default)]
155    #[serde(skip_serializing_if = "Option::is_none")]
156    pub portal_arn: Option<String>,
157    #[serde(rename = "userAccessLoggingSettingsArn")]
158    #[serde(default)]
159    #[serde(skip_serializing_if = "Option::is_none")]
160    pub user_access_logging_settings_arn: Option<String>,
161}
162
163#[derive(Debug, Clone, Default, Deserialize, Serialize)]
164pub struct AssociateUserSettingsRequest {
165    #[serde(rename = "portalArn")]
166    #[serde(default)]
167    pub portal_arn: String,
168    #[serde(rename = "userSettingsArn")]
169    #[serde(default)]
170    pub user_settings_arn: String,
171}
172
173#[derive(Debug, Clone, Default, Deserialize, Serialize)]
174pub struct AssociateUserSettingsResponse {
175    #[serde(rename = "portalArn")]
176    #[serde(default)]
177    #[serde(skip_serializing_if = "Option::is_none")]
178    pub portal_arn: Option<String>,
179    #[serde(rename = "userSettingsArn")]
180    #[serde(default)]
181    #[serde(skip_serializing_if = "Option::is_none")]
182    pub user_settings_arn: Option<String>,
183}
184
185#[derive(Debug, Clone, Default, Deserialize, Serialize)]
186pub struct CreateBrowserSettingsRequest {
187    #[serde(rename = "additionalEncryptionContext")]
188    #[serde(default)]
189    #[serde(skip_serializing_if = "Option::is_none")]
190    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
191    #[serde(rename = "browserPolicy")]
192    #[serde(default)]
193    #[serde(skip_serializing_if = "Option::is_none")]
194    pub browser_policy: Option<String>,
195    #[serde(rename = "clientToken")]
196    #[serde(default)]
197    #[serde(skip_serializing_if = "Option::is_none")]
198    pub client_token: Option<String>,
199    #[serde(rename = "customerManagedKey")]
200    #[serde(default)]
201    #[serde(skip_serializing_if = "Option::is_none")]
202    pub customer_managed_key: Option<String>,
203    #[serde(default)]
204    #[serde(skip_serializing_if = "Option::is_none")]
205    pub tags: Option<Vec<Tag>>,
206    #[serde(rename = "webContentFilteringPolicy")]
207    #[serde(default)]
208    #[serde(skip_serializing_if = "Option::is_none")]
209    pub web_content_filtering_policy: Option<WebContentFilteringPolicy>,
210}
211
212#[derive(Debug, Clone, Default, Deserialize, Serialize)]
213pub struct Tag {
214    #[serde(rename = "Key")]
215    #[serde(default)]
216    pub key: String,
217    #[serde(rename = "Value")]
218    #[serde(default)]
219    pub value: String,
220}
221
222#[derive(Debug, Clone, Default, Deserialize, Serialize)]
223pub struct WebContentFilteringPolicy {
224    #[serde(rename = "allowedUrls")]
225    #[serde(default)]
226    #[serde(skip_serializing_if = "Option::is_none")]
227    pub allowed_urls: Option<Vec<String>>,
228    #[serde(rename = "blockedCategories")]
229    #[serde(default)]
230    #[serde(skip_serializing_if = "Option::is_none")]
231    pub blocked_categories: Option<Vec<String>>,
232    #[serde(rename = "blockedUrls")]
233    #[serde(default)]
234    #[serde(skip_serializing_if = "Option::is_none")]
235    pub blocked_urls: Option<Vec<String>>,
236}
237
238#[derive(Debug, Clone, Default, Deserialize, Serialize)]
239pub struct CreateBrowserSettingsResponse {
240    #[serde(rename = "browserSettingsArn")]
241    #[serde(default)]
242    #[serde(skip_serializing_if = "Option::is_none")]
243    pub browser_settings_arn: Option<String>,
244}
245
246#[derive(Debug, Clone, Default, Deserialize, Serialize)]
247pub struct CreateDataProtectionSettingsRequest {
248    #[serde(rename = "additionalEncryptionContext")]
249    #[serde(default)]
250    #[serde(skip_serializing_if = "Option::is_none")]
251    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
252    #[serde(rename = "clientToken")]
253    #[serde(default)]
254    #[serde(skip_serializing_if = "Option::is_none")]
255    pub client_token: Option<String>,
256    #[serde(rename = "customerManagedKey")]
257    #[serde(default)]
258    #[serde(skip_serializing_if = "Option::is_none")]
259    pub customer_managed_key: Option<String>,
260    #[serde(default)]
261    #[serde(skip_serializing_if = "Option::is_none")]
262    pub description: Option<String>,
263    #[serde(rename = "displayName")]
264    #[serde(default)]
265    #[serde(skip_serializing_if = "Option::is_none")]
266    pub display_name: Option<String>,
267    #[serde(rename = "inlineRedactionConfiguration")]
268    #[serde(default)]
269    #[serde(skip_serializing_if = "Option::is_none")]
270    pub inline_redaction_configuration: Option<InlineRedactionConfiguration>,
271    #[serde(default)]
272    #[serde(skip_serializing_if = "Option::is_none")]
273    pub tags: Option<Vec<Tag>>,
274}
275
276#[derive(Debug, Clone, Default, Deserialize, Serialize)]
277pub struct InlineRedactionConfiguration {
278    #[serde(rename = "globalConfidenceLevel")]
279    #[serde(default)]
280    #[serde(skip_serializing_if = "Option::is_none")]
281    pub global_confidence_level: Option<i32>,
282    #[serde(rename = "globalEnforcedUrls")]
283    #[serde(default)]
284    #[serde(skip_serializing_if = "Option::is_none")]
285    pub global_enforced_urls: Option<Vec<String>>,
286    #[serde(rename = "globalExemptUrls")]
287    #[serde(default)]
288    #[serde(skip_serializing_if = "Option::is_none")]
289    pub global_exempt_urls: Option<Vec<String>>,
290    #[serde(rename = "inlineRedactionPatterns")]
291    #[serde(default)]
292    pub inline_redaction_patterns: Vec<InlineRedactionPattern>,
293}
294
295#[derive(Debug, Clone, Default, Deserialize, Serialize)]
296pub struct InlineRedactionPattern {
297    #[serde(rename = "builtInPatternId")]
298    #[serde(default)]
299    #[serde(skip_serializing_if = "Option::is_none")]
300    pub built_in_pattern_id: Option<String>,
301    #[serde(rename = "confidenceLevel")]
302    #[serde(default)]
303    #[serde(skip_serializing_if = "Option::is_none")]
304    pub confidence_level: Option<i32>,
305    #[serde(rename = "customPattern")]
306    #[serde(default)]
307    #[serde(skip_serializing_if = "Option::is_none")]
308    pub custom_pattern: Option<CustomPattern>,
309    #[serde(rename = "enforcedUrls")]
310    #[serde(default)]
311    #[serde(skip_serializing_if = "Option::is_none")]
312    pub enforced_urls: Option<Vec<String>>,
313    #[serde(rename = "exemptUrls")]
314    #[serde(default)]
315    #[serde(skip_serializing_if = "Option::is_none")]
316    pub exempt_urls: Option<Vec<String>>,
317    #[serde(rename = "redactionPlaceHolder")]
318    #[serde(default)]
319    pub redaction_place_holder: RedactionPlaceHolder,
320}
321
322#[derive(Debug, Clone, Default, Deserialize, Serialize)]
323pub struct CustomPattern {
324    #[serde(rename = "keywordRegex")]
325    #[serde(default)]
326    #[serde(skip_serializing_if = "Option::is_none")]
327    pub keyword_regex: Option<String>,
328    #[serde(rename = "patternDescription")]
329    #[serde(default)]
330    #[serde(skip_serializing_if = "Option::is_none")]
331    pub pattern_description: Option<String>,
332    #[serde(rename = "patternName")]
333    #[serde(default)]
334    pub pattern_name: String,
335    #[serde(rename = "patternRegex")]
336    #[serde(default)]
337    pub pattern_regex: String,
338}
339
340#[derive(Debug, Clone, Default, Deserialize, Serialize)]
341pub struct RedactionPlaceHolder {
342    #[serde(rename = "redactionPlaceHolderText")]
343    #[serde(default)]
344    #[serde(skip_serializing_if = "Option::is_none")]
345    pub redaction_place_holder_text: Option<String>,
346    #[serde(rename = "redactionPlaceHolderType")]
347    #[serde(default)]
348    pub redaction_place_holder_type: String,
349}
350
351#[derive(Debug, Clone, Default, Deserialize, Serialize)]
352pub struct CreateDataProtectionSettingsResponse {
353    #[serde(rename = "dataProtectionSettingsArn")]
354    #[serde(default)]
355    #[serde(skip_serializing_if = "Option::is_none")]
356    pub data_protection_settings_arn: Option<String>,
357}
358
359#[derive(Debug, Clone, Default, Deserialize, Serialize)]
360pub struct CreateIdentityProviderRequest {
361    #[serde(rename = "clientToken")]
362    #[serde(default)]
363    #[serde(skip_serializing_if = "Option::is_none")]
364    pub client_token: Option<String>,
365    #[serde(rename = "identityProviderDetails")]
366    #[serde(default)]
367    pub identity_provider_details: std::collections::HashMap<String, String>,
368    #[serde(rename = "identityProviderName")]
369    #[serde(default)]
370    pub identity_provider_name: String,
371    #[serde(rename = "identityProviderType")]
372    #[serde(default)]
373    pub identity_provider_type: String,
374    #[serde(rename = "portalArn")]
375    #[serde(default)]
376    pub portal_arn: String,
377    #[serde(default)]
378    #[serde(skip_serializing_if = "Option::is_none")]
379    pub tags: Option<Vec<Tag>>,
380}
381
382#[derive(Debug, Clone, Default, Deserialize, Serialize)]
383pub struct CreateIdentityProviderResponse {
384    #[serde(rename = "identityProviderArn")]
385    #[serde(default)]
386    #[serde(skip_serializing_if = "Option::is_none")]
387    pub identity_provider_arn: Option<String>,
388}
389
390#[derive(Debug, Clone, Default, Deserialize, Serialize)]
391pub struct CreateIpAccessSettingsRequest {
392    #[serde(rename = "additionalEncryptionContext")]
393    #[serde(default)]
394    #[serde(skip_serializing_if = "Option::is_none")]
395    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
396    #[serde(rename = "clientToken")]
397    #[serde(default)]
398    #[serde(skip_serializing_if = "Option::is_none")]
399    pub client_token: Option<String>,
400    #[serde(rename = "customerManagedKey")]
401    #[serde(default)]
402    #[serde(skip_serializing_if = "Option::is_none")]
403    pub customer_managed_key: Option<String>,
404    #[serde(default)]
405    #[serde(skip_serializing_if = "Option::is_none")]
406    pub description: Option<String>,
407    #[serde(rename = "displayName")]
408    #[serde(default)]
409    #[serde(skip_serializing_if = "Option::is_none")]
410    pub display_name: Option<String>,
411    #[serde(rename = "ipRules")]
412    #[serde(default)]
413    pub ip_rules: Vec<IpRule>,
414    #[serde(default)]
415    #[serde(skip_serializing_if = "Option::is_none")]
416    pub tags: Option<Vec<Tag>>,
417}
418
419#[derive(Debug, Clone, Default, Deserialize, Serialize)]
420pub struct IpRule {
421    #[serde(default)]
422    #[serde(skip_serializing_if = "Option::is_none")]
423    pub description: Option<String>,
424    #[serde(rename = "ipRange")]
425    #[serde(default)]
426    pub ip_range: String,
427}
428
429#[derive(Debug, Clone, Default, Deserialize, Serialize)]
430pub struct CreateIpAccessSettingsResponse {
431    #[serde(rename = "ipAccessSettingsArn")]
432    #[serde(default)]
433    #[serde(skip_serializing_if = "Option::is_none")]
434    pub ip_access_settings_arn: Option<String>,
435}
436
437#[derive(Debug, Clone, Default, Deserialize, Serialize)]
438pub struct CreateNetworkSettingsRequest {
439    #[serde(rename = "clientToken")]
440    #[serde(default)]
441    #[serde(skip_serializing_if = "Option::is_none")]
442    pub client_token: Option<String>,
443    #[serde(rename = "securityGroupIds")]
444    #[serde(default)]
445    pub security_group_ids: Vec<String>,
446    #[serde(rename = "subnetIds")]
447    #[serde(default)]
448    pub subnet_ids: Vec<String>,
449    #[serde(default)]
450    #[serde(skip_serializing_if = "Option::is_none")]
451    pub tags: Option<Vec<Tag>>,
452    #[serde(rename = "vpcId")]
453    #[serde(default)]
454    pub vpc_id: String,
455}
456
457#[derive(Debug, Clone, Default, Deserialize, Serialize)]
458pub struct CreateNetworkSettingsResponse {
459    #[serde(rename = "networkSettingsArn")]
460    #[serde(default)]
461    #[serde(skip_serializing_if = "Option::is_none")]
462    pub network_settings_arn: Option<String>,
463}
464
465#[derive(Debug, Clone, Default, Deserialize, Serialize)]
466pub struct CreatePortalRequest {
467    #[serde(rename = "additionalEncryptionContext")]
468    #[serde(default)]
469    #[serde(skip_serializing_if = "Option::is_none")]
470    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
471    #[serde(rename = "authenticationType")]
472    #[serde(default)]
473    #[serde(skip_serializing_if = "Option::is_none")]
474    pub authentication_type: Option<String>,
475    #[serde(rename = "clientToken")]
476    #[serde(default)]
477    #[serde(skip_serializing_if = "Option::is_none")]
478    pub client_token: Option<String>,
479    #[serde(rename = "customerManagedKey")]
480    #[serde(default)]
481    #[serde(skip_serializing_if = "Option::is_none")]
482    pub customer_managed_key: Option<String>,
483    #[serde(rename = "displayName")]
484    #[serde(default)]
485    #[serde(skip_serializing_if = "Option::is_none")]
486    pub display_name: Option<String>,
487    #[serde(rename = "instanceType")]
488    #[serde(default)]
489    #[serde(skip_serializing_if = "Option::is_none")]
490    pub instance_type: Option<String>,
491    #[serde(rename = "maxConcurrentSessions")]
492    #[serde(default)]
493    #[serde(skip_serializing_if = "Option::is_none")]
494    pub max_concurrent_sessions: Option<i32>,
495    #[serde(rename = "portalCustomDomain")]
496    #[serde(default)]
497    #[serde(skip_serializing_if = "Option::is_none")]
498    pub portal_custom_domain: Option<String>,
499    #[serde(default)]
500    #[serde(skip_serializing_if = "Option::is_none")]
501    pub tags: Option<Vec<Tag>>,
502}
503
504#[derive(Debug, Clone, Default, Deserialize, Serialize)]
505pub struct CreatePortalResponse {
506    #[serde(rename = "portalArn")]
507    #[serde(default)]
508    #[serde(skip_serializing_if = "Option::is_none")]
509    pub portal_arn: Option<String>,
510    #[serde(rename = "portalEndpoint")]
511    #[serde(default)]
512    #[serde(skip_serializing_if = "Option::is_none")]
513    pub portal_endpoint: Option<String>,
514}
515
516#[derive(Debug, Clone, Default, Deserialize, Serialize)]
517pub struct CreateSessionLoggerRequest {
518    #[serde(rename = "additionalEncryptionContext")]
519    #[serde(default)]
520    #[serde(skip_serializing_if = "Option::is_none")]
521    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
522    #[serde(rename = "clientToken")]
523    #[serde(default)]
524    #[serde(skip_serializing_if = "Option::is_none")]
525    pub client_token: Option<String>,
526    #[serde(rename = "customerManagedKey")]
527    #[serde(default)]
528    #[serde(skip_serializing_if = "Option::is_none")]
529    pub customer_managed_key: Option<String>,
530    #[serde(rename = "displayName")]
531    #[serde(default)]
532    #[serde(skip_serializing_if = "Option::is_none")]
533    pub display_name: Option<String>,
534    #[serde(rename = "eventFilter")]
535    #[serde(default)]
536    pub event_filter: EventFilter,
537    #[serde(rename = "logConfiguration")]
538    #[serde(default)]
539    pub log_configuration: LogConfiguration,
540    #[serde(default)]
541    #[serde(skip_serializing_if = "Option::is_none")]
542    pub tags: Option<Vec<Tag>>,
543}
544
545#[derive(Debug, Clone, Default, Deserialize, Serialize)]
546pub struct EventFilter {
547    #[serde(default)]
548    #[serde(skip_serializing_if = "Option::is_none")]
549    pub all: Option<String>,
550    #[serde(default)]
551    #[serde(skip_serializing_if = "Option::is_none")]
552    pub include: Option<Vec<String>>,
553}
554
555#[derive(Debug, Clone, Default, Deserialize, Serialize)]
556pub struct LogConfiguration {
557    #[serde(default)]
558    #[serde(skip_serializing_if = "Option::is_none")]
559    pub s3: Option<S3LogConfiguration>,
560}
561
562#[derive(Debug, Clone, Default, Deserialize, Serialize)]
563pub struct S3LogConfiguration {
564    #[serde(default)]
565    pub bucket: String,
566    #[serde(rename = "bucketOwner")]
567    #[serde(default)]
568    #[serde(skip_serializing_if = "Option::is_none")]
569    pub bucket_owner: Option<String>,
570    #[serde(rename = "folderStructure")]
571    #[serde(default)]
572    pub folder_structure: String,
573    #[serde(rename = "keyPrefix")]
574    #[serde(default)]
575    #[serde(skip_serializing_if = "Option::is_none")]
576    pub key_prefix: Option<String>,
577    #[serde(rename = "logFileFormat")]
578    #[serde(default)]
579    pub log_file_format: String,
580}
581
582#[derive(Debug, Clone, Default, Deserialize, Serialize)]
583pub struct CreateSessionLoggerResponse {
584    #[serde(rename = "sessionLoggerArn")]
585    #[serde(default)]
586    #[serde(skip_serializing_if = "Option::is_none")]
587    pub session_logger_arn: Option<String>,
588}
589
590#[derive(Debug, Clone, Default, Deserialize, Serialize)]
591pub struct CreateTrustStoreRequest {
592    #[serde(rename = "certificateList")]
593    #[serde(default)]
594    pub certificate_list: Vec<String>,
595    #[serde(rename = "clientToken")]
596    #[serde(default)]
597    #[serde(skip_serializing_if = "Option::is_none")]
598    pub client_token: Option<String>,
599    #[serde(default)]
600    #[serde(skip_serializing_if = "Option::is_none")]
601    pub tags: Option<Vec<Tag>>,
602}
603
604#[derive(Debug, Clone, Default, Deserialize, Serialize)]
605pub struct CreateTrustStoreResponse {
606    #[serde(rename = "trustStoreArn")]
607    #[serde(default)]
608    #[serde(skip_serializing_if = "Option::is_none")]
609    pub trust_store_arn: Option<String>,
610}
611
612#[derive(Debug, Clone, Default, Deserialize, Serialize)]
613pub struct CreateUserAccessLoggingSettingsRequest {
614    #[serde(rename = "clientToken")]
615    #[serde(default)]
616    #[serde(skip_serializing_if = "Option::is_none")]
617    pub client_token: Option<String>,
618    #[serde(rename = "kinesisStreamArn")]
619    #[serde(default)]
620    pub kinesis_stream_arn: String,
621    #[serde(default)]
622    #[serde(skip_serializing_if = "Option::is_none")]
623    pub tags: Option<Vec<Tag>>,
624}
625
626#[derive(Debug, Clone, Default, Deserialize, Serialize)]
627pub struct CreateUserAccessLoggingSettingsResponse {
628    #[serde(rename = "userAccessLoggingSettingsArn")]
629    #[serde(default)]
630    #[serde(skip_serializing_if = "Option::is_none")]
631    pub user_access_logging_settings_arn: Option<String>,
632}
633
634#[derive(Debug, Clone, Default, Deserialize, Serialize)]
635pub struct CreateUserSettingsRequest {
636    #[serde(rename = "additionalEncryptionContext")]
637    #[serde(default)]
638    #[serde(skip_serializing_if = "Option::is_none")]
639    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
640    #[serde(rename = "brandingConfigurationInput")]
641    #[serde(default)]
642    #[serde(skip_serializing_if = "Option::is_none")]
643    pub branding_configuration_input: Option<BrandingConfigurationCreateInput>,
644    #[serde(rename = "clientToken")]
645    #[serde(default)]
646    #[serde(skip_serializing_if = "Option::is_none")]
647    pub client_token: Option<String>,
648    #[serde(rename = "cookieSynchronizationConfiguration")]
649    #[serde(default)]
650    #[serde(skip_serializing_if = "Option::is_none")]
651    pub cookie_synchronization_configuration: Option<CookieSynchronizationConfiguration>,
652    #[serde(rename = "copyAllowed")]
653    #[serde(default)]
654    pub copy_allowed: String,
655    #[serde(rename = "customerManagedKey")]
656    #[serde(default)]
657    #[serde(skip_serializing_if = "Option::is_none")]
658    pub customer_managed_key: Option<String>,
659    #[serde(rename = "deepLinkAllowed")]
660    #[serde(default)]
661    #[serde(skip_serializing_if = "Option::is_none")]
662    pub deep_link_allowed: Option<String>,
663    #[serde(rename = "disconnectTimeoutInMinutes")]
664    #[serde(default)]
665    #[serde(skip_serializing_if = "Option::is_none")]
666    pub disconnect_timeout_in_minutes: Option<i32>,
667    #[serde(rename = "downloadAllowed")]
668    #[serde(default)]
669    pub download_allowed: String,
670    #[serde(rename = "idleDisconnectTimeoutInMinutes")]
671    #[serde(default)]
672    #[serde(skip_serializing_if = "Option::is_none")]
673    pub idle_disconnect_timeout_in_minutes: Option<i32>,
674    #[serde(rename = "pasteAllowed")]
675    #[serde(default)]
676    pub paste_allowed: String,
677    #[serde(rename = "printAllowed")]
678    #[serde(default)]
679    pub print_allowed: String,
680    #[serde(default)]
681    #[serde(skip_serializing_if = "Option::is_none")]
682    pub tags: Option<Vec<Tag>>,
683    #[serde(rename = "toolbarConfiguration")]
684    #[serde(default)]
685    #[serde(skip_serializing_if = "Option::is_none")]
686    pub toolbar_configuration: Option<ToolbarConfiguration>,
687    #[serde(rename = "uploadAllowed")]
688    #[serde(default)]
689    pub upload_allowed: String,
690    #[serde(rename = "webAuthnAllowed")]
691    #[serde(default)]
692    #[serde(skip_serializing_if = "Option::is_none")]
693    pub web_authn_allowed: Option<String>,
694}
695
696#[derive(Debug, Clone, Default, Deserialize, Serialize)]
697pub struct BrandingConfigurationCreateInput {
698    #[serde(rename = "colorTheme")]
699    #[serde(default)]
700    pub color_theme: String,
701    #[serde(default)]
702    pub favicon: IconImageInput,
703    #[serde(rename = "localizedStrings")]
704    #[serde(default)]
705    pub localized_strings: std::collections::HashMap<String, LocalizedBrandingStrings>,
706    #[serde(default)]
707    pub logo: IconImageInput,
708    #[serde(rename = "termsOfService")]
709    #[serde(default)]
710    #[serde(skip_serializing_if = "Option::is_none")]
711    pub terms_of_service: Option<String>,
712    #[serde(default)]
713    #[serde(skip_serializing_if = "Option::is_none")]
714    pub wallpaper: Option<WallpaperImageInput>,
715}
716
717#[derive(Debug, Clone, Default, Deserialize, Serialize)]
718pub struct IconImageInput {
719    #[serde(default)]
720    #[serde(skip_serializing_if = "Option::is_none")]
721    pub blob: Option<String>,
722    #[serde(rename = "s3Uri")]
723    #[serde(default)]
724    #[serde(skip_serializing_if = "Option::is_none")]
725    pub s3_uri: Option<String>,
726}
727
728#[derive(Debug, Clone, Default, Deserialize, Serialize)]
729pub struct LocalizedBrandingStrings {
730    #[serde(rename = "browserTabTitle")]
731    #[serde(default)]
732    pub browser_tab_title: String,
733    #[serde(rename = "contactButtonText")]
734    #[serde(default)]
735    #[serde(skip_serializing_if = "Option::is_none")]
736    pub contact_button_text: Option<String>,
737    #[serde(rename = "contactLink")]
738    #[serde(default)]
739    #[serde(skip_serializing_if = "Option::is_none")]
740    pub contact_link: Option<String>,
741    #[serde(rename = "loadingText")]
742    #[serde(default)]
743    #[serde(skip_serializing_if = "Option::is_none")]
744    pub loading_text: Option<String>,
745    #[serde(rename = "loginButtonText")]
746    #[serde(default)]
747    #[serde(skip_serializing_if = "Option::is_none")]
748    pub login_button_text: Option<String>,
749    #[serde(rename = "loginDescription")]
750    #[serde(default)]
751    #[serde(skip_serializing_if = "Option::is_none")]
752    pub login_description: Option<String>,
753    #[serde(rename = "loginTitle")]
754    #[serde(default)]
755    #[serde(skip_serializing_if = "Option::is_none")]
756    pub login_title: Option<String>,
757    #[serde(rename = "welcomeText")]
758    #[serde(default)]
759    pub welcome_text: String,
760}
761
762#[derive(Debug, Clone, Default, Deserialize, Serialize)]
763pub struct WallpaperImageInput {
764    #[serde(default)]
765    #[serde(skip_serializing_if = "Option::is_none")]
766    pub blob: Option<String>,
767    #[serde(rename = "s3Uri")]
768    #[serde(default)]
769    #[serde(skip_serializing_if = "Option::is_none")]
770    pub s3_uri: Option<String>,
771}
772
773#[derive(Debug, Clone, Default, Deserialize, Serialize)]
774pub struct CookieSynchronizationConfiguration {
775    #[serde(default)]
776    pub allowlist: Vec<CookieSpecification>,
777    #[serde(default)]
778    #[serde(skip_serializing_if = "Option::is_none")]
779    pub blocklist: Option<Vec<CookieSpecification>>,
780}
781
782#[derive(Debug, Clone, Default, Deserialize, Serialize)]
783pub struct CookieSpecification {
784    #[serde(default)]
785    pub domain: String,
786    #[serde(default)]
787    #[serde(skip_serializing_if = "Option::is_none")]
788    pub name: Option<String>,
789    #[serde(default)]
790    #[serde(skip_serializing_if = "Option::is_none")]
791    pub path: Option<String>,
792}
793
794#[derive(Debug, Clone, Default, Deserialize, Serialize)]
795pub struct ToolbarConfiguration {
796    #[serde(rename = "hiddenToolbarItems")]
797    #[serde(default)]
798    #[serde(skip_serializing_if = "Option::is_none")]
799    pub hidden_toolbar_items: Option<Vec<String>>,
800    #[serde(rename = "maxDisplayResolution")]
801    #[serde(default)]
802    #[serde(skip_serializing_if = "Option::is_none")]
803    pub max_display_resolution: Option<String>,
804    #[serde(rename = "toolbarType")]
805    #[serde(default)]
806    #[serde(skip_serializing_if = "Option::is_none")]
807    pub toolbar_type: Option<String>,
808    #[serde(rename = "visualMode")]
809    #[serde(default)]
810    #[serde(skip_serializing_if = "Option::is_none")]
811    pub visual_mode: Option<String>,
812}
813
814#[derive(Debug, Clone, Default, Deserialize, Serialize)]
815pub struct CreateUserSettingsResponse {
816    #[serde(rename = "userSettingsArn")]
817    #[serde(default)]
818    #[serde(skip_serializing_if = "Option::is_none")]
819    pub user_settings_arn: Option<String>,
820}
821
822#[derive(Debug, Clone, Default, Deserialize, Serialize)]
823pub struct DeleteBrowserSettingsRequest {
824    #[serde(rename = "browserSettingsArn")]
825    #[serde(default)]
826    pub browser_settings_arn: String,
827}
828
829#[derive(Debug, Clone, Default, Deserialize, Serialize)]
830pub struct DeleteBrowserSettingsResponse {}
831
832#[derive(Debug, Clone, Default, Deserialize, Serialize)]
833pub struct DeleteDataProtectionSettingsRequest {
834    #[serde(rename = "dataProtectionSettingsArn")]
835    #[serde(default)]
836    pub data_protection_settings_arn: String,
837}
838
839#[derive(Debug, Clone, Default, Deserialize, Serialize)]
840pub struct DeleteDataProtectionSettingsResponse {}
841
842#[derive(Debug, Clone, Default, Deserialize, Serialize)]
843pub struct DeleteIdentityProviderRequest {
844    #[serde(rename = "identityProviderArn")]
845    #[serde(default)]
846    pub identity_provider_arn: String,
847}
848
849#[derive(Debug, Clone, Default, Deserialize, Serialize)]
850pub struct DeleteIdentityProviderResponse {}
851
852#[derive(Debug, Clone, Default, Deserialize, Serialize)]
853pub struct DeleteIpAccessSettingsRequest {
854    #[serde(rename = "ipAccessSettingsArn")]
855    #[serde(default)]
856    pub ip_access_settings_arn: String,
857}
858
859#[derive(Debug, Clone, Default, Deserialize, Serialize)]
860pub struct DeleteIpAccessSettingsResponse {}
861
862#[derive(Debug, Clone, Default, Deserialize, Serialize)]
863pub struct DeleteNetworkSettingsRequest {
864    #[serde(rename = "networkSettingsArn")]
865    #[serde(default)]
866    pub network_settings_arn: String,
867}
868
869#[derive(Debug, Clone, Default, Deserialize, Serialize)]
870pub struct DeleteNetworkSettingsResponse {}
871
872#[derive(Debug, Clone, Default, Deserialize, Serialize)]
873pub struct DeletePortalRequest {
874    #[serde(rename = "portalArn")]
875    #[serde(default)]
876    pub portal_arn: String,
877}
878
879#[derive(Debug, Clone, Default, Deserialize, Serialize)]
880pub struct DeletePortalResponse {}
881
882#[derive(Debug, Clone, Default, Deserialize, Serialize)]
883pub struct DeleteSessionLoggerRequest {
884    #[serde(rename = "sessionLoggerArn")]
885    #[serde(default)]
886    pub session_logger_arn: String,
887}
888
889#[derive(Debug, Clone, Default, Deserialize, Serialize)]
890pub struct DeleteSessionLoggerResponse {}
891
892#[derive(Debug, Clone, Default, Deserialize, Serialize)]
893pub struct DeleteTrustStoreRequest {
894    #[serde(rename = "trustStoreArn")]
895    #[serde(default)]
896    pub trust_store_arn: String,
897}
898
899#[derive(Debug, Clone, Default, Deserialize, Serialize)]
900pub struct DeleteTrustStoreResponse {}
901
902#[derive(Debug, Clone, Default, Deserialize, Serialize)]
903pub struct DeleteUserAccessLoggingSettingsRequest {
904    #[serde(rename = "userAccessLoggingSettingsArn")]
905    #[serde(default)]
906    pub user_access_logging_settings_arn: String,
907}
908
909#[derive(Debug, Clone, Default, Deserialize, Serialize)]
910pub struct DeleteUserAccessLoggingSettingsResponse {}
911
912#[derive(Debug, Clone, Default, Deserialize, Serialize)]
913pub struct DeleteUserSettingsRequest {
914    #[serde(rename = "userSettingsArn")]
915    #[serde(default)]
916    pub user_settings_arn: String,
917}
918
919#[derive(Debug, Clone, Default, Deserialize, Serialize)]
920pub struct DeleteUserSettingsResponse {}
921
922#[derive(Debug, Clone, Default, Deserialize, Serialize)]
923pub struct DisassociateBrowserSettingsRequest {
924    #[serde(rename = "portalArn")]
925    #[serde(default)]
926    pub portal_arn: String,
927}
928
929#[derive(Debug, Clone, Default, Deserialize, Serialize)]
930pub struct DisassociateBrowserSettingsResponse {}
931
932#[derive(Debug, Clone, Default, Deserialize, Serialize)]
933pub struct DisassociateDataProtectionSettingsRequest {
934    #[serde(rename = "portalArn")]
935    #[serde(default)]
936    pub portal_arn: String,
937}
938
939#[derive(Debug, Clone, Default, Deserialize, Serialize)]
940pub struct DisassociateDataProtectionSettingsResponse {}
941
942#[derive(Debug, Clone, Default, Deserialize, Serialize)]
943pub struct DisassociateIpAccessSettingsRequest {
944    #[serde(rename = "portalArn")]
945    #[serde(default)]
946    pub portal_arn: String,
947}
948
949#[derive(Debug, Clone, Default, Deserialize, Serialize)]
950pub struct DisassociateIpAccessSettingsResponse {}
951
952#[derive(Debug, Clone, Default, Deserialize, Serialize)]
953pub struct DisassociateNetworkSettingsRequest {
954    #[serde(rename = "portalArn")]
955    #[serde(default)]
956    pub portal_arn: String,
957}
958
959#[derive(Debug, Clone, Default, Deserialize, Serialize)]
960pub struct DisassociateNetworkSettingsResponse {}
961
962#[derive(Debug, Clone, Default, Deserialize, Serialize)]
963pub struct DisassociateSessionLoggerRequest {
964    #[serde(rename = "portalArn")]
965    #[serde(default)]
966    pub portal_arn: String,
967}
968
969#[derive(Debug, Clone, Default, Deserialize, Serialize)]
970pub struct DisassociateSessionLoggerResponse {}
971
972#[derive(Debug, Clone, Default, Deserialize, Serialize)]
973pub struct DisassociateTrustStoreRequest {
974    #[serde(rename = "portalArn")]
975    #[serde(default)]
976    pub portal_arn: String,
977}
978
979#[derive(Debug, Clone, Default, Deserialize, Serialize)]
980pub struct DisassociateTrustStoreResponse {}
981
982#[derive(Debug, Clone, Default, Deserialize, Serialize)]
983pub struct DisassociateUserAccessLoggingSettingsRequest {
984    #[serde(rename = "portalArn")]
985    #[serde(default)]
986    pub portal_arn: String,
987}
988
989#[derive(Debug, Clone, Default, Deserialize, Serialize)]
990pub struct DisassociateUserAccessLoggingSettingsResponse {}
991
992#[derive(Debug, Clone, Default, Deserialize, Serialize)]
993pub struct DisassociateUserSettingsRequest {
994    #[serde(rename = "portalArn")]
995    #[serde(default)]
996    pub portal_arn: String,
997}
998
999#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1000pub struct DisassociateUserSettingsResponse {}
1001
1002#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1003pub struct ExpireSessionRequest {
1004    #[serde(rename = "portalId")]
1005    #[serde(default)]
1006    pub portal_id: String,
1007    #[serde(rename = "sessionId")]
1008    #[serde(default)]
1009    pub session_id: String,
1010}
1011
1012#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1013pub struct ExpireSessionResponse {}
1014
1015#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1016pub struct GetBrowserSettingsRequest {
1017    #[serde(rename = "browserSettingsArn")]
1018    #[serde(default)]
1019    pub browser_settings_arn: String,
1020}
1021
1022#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1023pub struct GetBrowserSettingsResponse {
1024    #[serde(rename = "browserSettings")]
1025    #[serde(default)]
1026    #[serde(skip_serializing_if = "Option::is_none")]
1027    pub browser_settings: Option<BrowserSettings>,
1028}
1029
1030#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1031pub struct BrowserSettings {
1032    #[serde(rename = "additionalEncryptionContext")]
1033    #[serde(default)]
1034    #[serde(skip_serializing_if = "Option::is_none")]
1035    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
1036    #[serde(rename = "associatedPortalArns")]
1037    #[serde(default)]
1038    #[serde(skip_serializing_if = "Option::is_none")]
1039    pub associated_portal_arns: Option<Vec<String>>,
1040    #[serde(rename = "browserPolicy")]
1041    #[serde(default)]
1042    #[serde(skip_serializing_if = "Option::is_none")]
1043    pub browser_policy: Option<String>,
1044    #[serde(rename = "browserSettingsArn")]
1045    #[serde(default)]
1046    #[serde(skip_serializing_if = "Option::is_none")]
1047    pub browser_settings_arn: Option<String>,
1048    #[serde(rename = "customerManagedKey")]
1049    #[serde(default)]
1050    #[serde(skip_serializing_if = "Option::is_none")]
1051    pub customer_managed_key: Option<String>,
1052    #[serde(rename = "webContentFilteringPolicy")]
1053    #[serde(default)]
1054    #[serde(skip_serializing_if = "Option::is_none")]
1055    pub web_content_filtering_policy: Option<WebContentFilteringPolicy>,
1056}
1057
1058#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1059pub struct GetDataProtectionSettingsRequest {
1060    #[serde(rename = "dataProtectionSettingsArn")]
1061    #[serde(default)]
1062    pub data_protection_settings_arn: String,
1063}
1064
1065#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1066pub struct GetDataProtectionSettingsResponse {
1067    #[serde(rename = "dataProtectionSettings")]
1068    #[serde(default)]
1069    #[serde(skip_serializing_if = "Option::is_none")]
1070    pub data_protection_settings: Option<DataProtectionSettings>,
1071}
1072
1073#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1074pub struct DataProtectionSettings {
1075    #[serde(rename = "additionalEncryptionContext")]
1076    #[serde(default)]
1077    #[serde(skip_serializing_if = "Option::is_none")]
1078    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
1079    #[serde(rename = "associatedPortalArns")]
1080    #[serde(default)]
1081    #[serde(skip_serializing_if = "Option::is_none")]
1082    pub associated_portal_arns: Option<Vec<String>>,
1083    #[serde(rename = "creationDate")]
1084    #[serde(default)]
1085    #[serde(skip_serializing_if = "Option::is_none")]
1086    pub creation_date: Option<f64>,
1087    #[serde(rename = "customerManagedKey")]
1088    #[serde(default)]
1089    #[serde(skip_serializing_if = "Option::is_none")]
1090    pub customer_managed_key: Option<String>,
1091    #[serde(rename = "dataProtectionSettingsArn")]
1092    #[serde(default)]
1093    #[serde(skip_serializing_if = "Option::is_none")]
1094    pub data_protection_settings_arn: Option<String>,
1095    #[serde(default)]
1096    #[serde(skip_serializing_if = "Option::is_none")]
1097    pub description: Option<String>,
1098    #[serde(rename = "displayName")]
1099    #[serde(default)]
1100    #[serde(skip_serializing_if = "Option::is_none")]
1101    pub display_name: Option<String>,
1102    #[serde(rename = "inlineRedactionConfiguration")]
1103    #[serde(default)]
1104    #[serde(skip_serializing_if = "Option::is_none")]
1105    pub inline_redaction_configuration: Option<InlineRedactionConfiguration>,
1106}
1107
1108#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1109pub struct GetIdentityProviderRequest {
1110    #[serde(rename = "identityProviderArn")]
1111    #[serde(default)]
1112    pub identity_provider_arn: String,
1113}
1114
1115#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1116pub struct GetIdentityProviderResponse {
1117    #[serde(rename = "identityProvider")]
1118    #[serde(default)]
1119    #[serde(skip_serializing_if = "Option::is_none")]
1120    pub identity_provider: Option<IdentityProvider>,
1121}
1122
1123#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1124pub struct IdentityProvider {
1125    #[serde(rename = "identityProviderArn")]
1126    #[serde(default)]
1127    #[serde(skip_serializing_if = "Option::is_none")]
1128    pub identity_provider_arn: Option<String>,
1129    #[serde(rename = "identityProviderDetails")]
1130    #[serde(default)]
1131    #[serde(skip_serializing_if = "Option::is_none")]
1132    pub identity_provider_details: Option<std::collections::HashMap<String, String>>,
1133    #[serde(rename = "identityProviderName")]
1134    #[serde(default)]
1135    #[serde(skip_serializing_if = "Option::is_none")]
1136    pub identity_provider_name: Option<String>,
1137    #[serde(rename = "identityProviderType")]
1138    #[serde(default)]
1139    #[serde(skip_serializing_if = "Option::is_none")]
1140    pub identity_provider_type: Option<String>,
1141}
1142
1143#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1144pub struct GetIpAccessSettingsRequest {
1145    #[serde(rename = "ipAccessSettingsArn")]
1146    #[serde(default)]
1147    pub ip_access_settings_arn: String,
1148}
1149
1150#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1151pub struct GetIpAccessSettingsResponse {
1152    #[serde(rename = "ipAccessSettings")]
1153    #[serde(default)]
1154    #[serde(skip_serializing_if = "Option::is_none")]
1155    pub ip_access_settings: Option<IpAccessSettings>,
1156}
1157
1158#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1159pub struct IpAccessSettings {
1160    #[serde(rename = "additionalEncryptionContext")]
1161    #[serde(default)]
1162    #[serde(skip_serializing_if = "Option::is_none")]
1163    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
1164    #[serde(rename = "associatedPortalArns")]
1165    #[serde(default)]
1166    #[serde(skip_serializing_if = "Option::is_none")]
1167    pub associated_portal_arns: Option<Vec<String>>,
1168    #[serde(rename = "creationDate")]
1169    #[serde(default)]
1170    #[serde(skip_serializing_if = "Option::is_none")]
1171    pub creation_date: Option<f64>,
1172    #[serde(rename = "customerManagedKey")]
1173    #[serde(default)]
1174    #[serde(skip_serializing_if = "Option::is_none")]
1175    pub customer_managed_key: Option<String>,
1176    #[serde(default)]
1177    #[serde(skip_serializing_if = "Option::is_none")]
1178    pub description: Option<String>,
1179    #[serde(rename = "displayName")]
1180    #[serde(default)]
1181    #[serde(skip_serializing_if = "Option::is_none")]
1182    pub display_name: Option<String>,
1183    #[serde(rename = "ipAccessSettingsArn")]
1184    #[serde(default)]
1185    #[serde(skip_serializing_if = "Option::is_none")]
1186    pub ip_access_settings_arn: Option<String>,
1187    #[serde(rename = "ipRules")]
1188    #[serde(default)]
1189    #[serde(skip_serializing_if = "Option::is_none")]
1190    pub ip_rules: Option<Vec<IpRule>>,
1191}
1192
1193#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1194pub struct GetNetworkSettingsRequest {
1195    #[serde(rename = "networkSettingsArn")]
1196    #[serde(default)]
1197    pub network_settings_arn: String,
1198}
1199
1200#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1201pub struct GetNetworkSettingsResponse {
1202    #[serde(rename = "networkSettings")]
1203    #[serde(default)]
1204    #[serde(skip_serializing_if = "Option::is_none")]
1205    pub network_settings: Option<NetworkSettings>,
1206}
1207
1208#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1209pub struct NetworkSettings {
1210    #[serde(rename = "associatedPortalArns")]
1211    #[serde(default)]
1212    #[serde(skip_serializing_if = "Option::is_none")]
1213    pub associated_portal_arns: Option<Vec<String>>,
1214    #[serde(rename = "networkSettingsArn")]
1215    #[serde(default)]
1216    #[serde(skip_serializing_if = "Option::is_none")]
1217    pub network_settings_arn: Option<String>,
1218    #[serde(rename = "securityGroupIds")]
1219    #[serde(default)]
1220    #[serde(skip_serializing_if = "Option::is_none")]
1221    pub security_group_ids: Option<Vec<String>>,
1222    #[serde(rename = "subnetIds")]
1223    #[serde(default)]
1224    #[serde(skip_serializing_if = "Option::is_none")]
1225    pub subnet_ids: Option<Vec<String>>,
1226    #[serde(rename = "vpcId")]
1227    #[serde(default)]
1228    #[serde(skip_serializing_if = "Option::is_none")]
1229    pub vpc_id: Option<String>,
1230}
1231
1232#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1233pub struct GetPortalRequest {
1234    #[serde(rename = "portalArn")]
1235    #[serde(default)]
1236    pub portal_arn: String,
1237}
1238
1239#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1240pub struct GetPortalResponse {
1241    #[serde(default)]
1242    #[serde(skip_serializing_if = "Option::is_none")]
1243    pub portal: Option<Portal>,
1244}
1245
1246#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1247pub struct Portal {
1248    #[serde(rename = "additionalEncryptionContext")]
1249    #[serde(default)]
1250    #[serde(skip_serializing_if = "Option::is_none")]
1251    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
1252    #[serde(rename = "authenticationType")]
1253    #[serde(default)]
1254    #[serde(skip_serializing_if = "Option::is_none")]
1255    pub authentication_type: Option<String>,
1256    #[serde(rename = "browserSettingsArn")]
1257    #[serde(default)]
1258    #[serde(skip_serializing_if = "Option::is_none")]
1259    pub browser_settings_arn: Option<String>,
1260    #[serde(rename = "browserType")]
1261    #[serde(default)]
1262    #[serde(skip_serializing_if = "Option::is_none")]
1263    pub browser_type: Option<String>,
1264    #[serde(rename = "creationDate")]
1265    #[serde(default)]
1266    #[serde(skip_serializing_if = "Option::is_none")]
1267    pub creation_date: Option<f64>,
1268    #[serde(rename = "customerManagedKey")]
1269    #[serde(default)]
1270    #[serde(skip_serializing_if = "Option::is_none")]
1271    pub customer_managed_key: Option<String>,
1272    #[serde(rename = "dataProtectionSettingsArn")]
1273    #[serde(default)]
1274    #[serde(skip_serializing_if = "Option::is_none")]
1275    pub data_protection_settings_arn: Option<String>,
1276    #[serde(rename = "displayName")]
1277    #[serde(default)]
1278    #[serde(skip_serializing_if = "Option::is_none")]
1279    pub display_name: Option<String>,
1280    #[serde(rename = "instanceType")]
1281    #[serde(default)]
1282    #[serde(skip_serializing_if = "Option::is_none")]
1283    pub instance_type: Option<String>,
1284    #[serde(rename = "ipAccessSettingsArn")]
1285    #[serde(default)]
1286    #[serde(skip_serializing_if = "Option::is_none")]
1287    pub ip_access_settings_arn: Option<String>,
1288    #[serde(rename = "maxConcurrentSessions")]
1289    #[serde(default)]
1290    #[serde(skip_serializing_if = "Option::is_none")]
1291    pub max_concurrent_sessions: Option<i32>,
1292    #[serde(rename = "networkSettingsArn")]
1293    #[serde(default)]
1294    #[serde(skip_serializing_if = "Option::is_none")]
1295    pub network_settings_arn: Option<String>,
1296    #[serde(rename = "portalArn")]
1297    #[serde(default)]
1298    #[serde(skip_serializing_if = "Option::is_none")]
1299    pub portal_arn: Option<String>,
1300    #[serde(rename = "portalCustomDomain")]
1301    #[serde(default)]
1302    #[serde(skip_serializing_if = "Option::is_none")]
1303    pub portal_custom_domain: Option<String>,
1304    #[serde(rename = "portalEndpoint")]
1305    #[serde(default)]
1306    #[serde(skip_serializing_if = "Option::is_none")]
1307    pub portal_endpoint: Option<String>,
1308    #[serde(rename = "portalStatus")]
1309    #[serde(default)]
1310    #[serde(skip_serializing_if = "Option::is_none")]
1311    pub portal_status: Option<String>,
1312    #[serde(rename = "rendererType")]
1313    #[serde(default)]
1314    #[serde(skip_serializing_if = "Option::is_none")]
1315    pub renderer_type: Option<String>,
1316    #[serde(rename = "sessionLoggerArn")]
1317    #[serde(default)]
1318    #[serde(skip_serializing_if = "Option::is_none")]
1319    pub session_logger_arn: Option<String>,
1320    #[serde(rename = "statusReason")]
1321    #[serde(default)]
1322    #[serde(skip_serializing_if = "Option::is_none")]
1323    pub status_reason: Option<String>,
1324    #[serde(rename = "trustStoreArn")]
1325    #[serde(default)]
1326    #[serde(skip_serializing_if = "Option::is_none")]
1327    pub trust_store_arn: Option<String>,
1328    #[serde(rename = "userAccessLoggingSettingsArn")]
1329    #[serde(default)]
1330    #[serde(skip_serializing_if = "Option::is_none")]
1331    pub user_access_logging_settings_arn: Option<String>,
1332    #[serde(rename = "userSettingsArn")]
1333    #[serde(default)]
1334    #[serde(skip_serializing_if = "Option::is_none")]
1335    pub user_settings_arn: Option<String>,
1336}
1337
1338#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1339pub struct GetPortalServiceProviderMetadataRequest {
1340    #[serde(rename = "portalArn")]
1341    #[serde(default)]
1342    pub portal_arn: String,
1343}
1344
1345#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1346pub struct GetPortalServiceProviderMetadataResponse {
1347    #[serde(rename = "portalArn")]
1348    #[serde(default)]
1349    #[serde(skip_serializing_if = "Option::is_none")]
1350    pub portal_arn: Option<String>,
1351    #[serde(rename = "serviceProviderSamlMetadata")]
1352    #[serde(default)]
1353    #[serde(skip_serializing_if = "Option::is_none")]
1354    pub service_provider_saml_metadata: Option<String>,
1355}
1356
1357#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1358pub struct GetSessionLoggerRequest {
1359    #[serde(rename = "sessionLoggerArn")]
1360    #[serde(default)]
1361    pub session_logger_arn: String,
1362}
1363
1364#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1365pub struct GetSessionLoggerResponse {
1366    #[serde(rename = "sessionLogger")]
1367    #[serde(default)]
1368    #[serde(skip_serializing_if = "Option::is_none")]
1369    pub session_logger: Option<SessionLogger>,
1370}
1371
1372#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1373pub struct SessionLogger {
1374    #[serde(rename = "additionalEncryptionContext")]
1375    #[serde(default)]
1376    #[serde(skip_serializing_if = "Option::is_none")]
1377    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
1378    #[serde(rename = "associatedPortalArns")]
1379    #[serde(default)]
1380    #[serde(skip_serializing_if = "Option::is_none")]
1381    pub associated_portal_arns: Option<Vec<String>>,
1382    #[serde(rename = "creationDate")]
1383    #[serde(default)]
1384    #[serde(skip_serializing_if = "Option::is_none")]
1385    pub creation_date: Option<f64>,
1386    #[serde(rename = "customerManagedKey")]
1387    #[serde(default)]
1388    #[serde(skip_serializing_if = "Option::is_none")]
1389    pub customer_managed_key: Option<String>,
1390    #[serde(rename = "displayName")]
1391    #[serde(default)]
1392    #[serde(skip_serializing_if = "Option::is_none")]
1393    pub display_name: Option<String>,
1394    #[serde(rename = "eventFilter")]
1395    #[serde(default)]
1396    #[serde(skip_serializing_if = "Option::is_none")]
1397    pub event_filter: Option<EventFilter>,
1398    #[serde(rename = "logConfiguration")]
1399    #[serde(default)]
1400    #[serde(skip_serializing_if = "Option::is_none")]
1401    pub log_configuration: Option<LogConfiguration>,
1402    #[serde(rename = "sessionLoggerArn")]
1403    #[serde(default)]
1404    #[serde(skip_serializing_if = "Option::is_none")]
1405    pub session_logger_arn: Option<String>,
1406}
1407
1408#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1409pub struct GetSessionRequest {
1410    #[serde(rename = "portalId")]
1411    #[serde(default)]
1412    pub portal_id: String,
1413    #[serde(rename = "sessionId")]
1414    #[serde(default)]
1415    pub session_id: String,
1416}
1417
1418#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1419pub struct GetSessionResponse {
1420    #[serde(default)]
1421    #[serde(skip_serializing_if = "Option::is_none")]
1422    pub session: Option<Session>,
1423}
1424
1425#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1426pub struct Session {
1427    #[serde(rename = "clientIpAddresses")]
1428    #[serde(default)]
1429    #[serde(skip_serializing_if = "Option::is_none")]
1430    pub client_ip_addresses: Option<Vec<String>>,
1431    #[serde(rename = "endTime")]
1432    #[serde(default)]
1433    #[serde(skip_serializing_if = "Option::is_none")]
1434    pub end_time: Option<f64>,
1435    #[serde(rename = "portalArn")]
1436    #[serde(default)]
1437    #[serde(skip_serializing_if = "Option::is_none")]
1438    pub portal_arn: Option<String>,
1439    #[serde(rename = "sessionId")]
1440    #[serde(default)]
1441    #[serde(skip_serializing_if = "Option::is_none")]
1442    pub session_id: Option<String>,
1443    #[serde(rename = "startTime")]
1444    #[serde(default)]
1445    #[serde(skip_serializing_if = "Option::is_none")]
1446    pub start_time: Option<f64>,
1447    #[serde(default)]
1448    #[serde(skip_serializing_if = "Option::is_none")]
1449    pub status: Option<String>,
1450    #[serde(default)]
1451    #[serde(skip_serializing_if = "Option::is_none")]
1452    pub username: Option<String>,
1453}
1454
1455#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1456pub struct GetTrustStoreCertificateRequest {
1457    #[serde(default)]
1458    pub thumbprint: String,
1459    #[serde(rename = "trustStoreArn")]
1460    #[serde(default)]
1461    pub trust_store_arn: String,
1462}
1463
1464#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1465pub struct GetTrustStoreCertificateResponse {
1466    #[serde(default)]
1467    #[serde(skip_serializing_if = "Option::is_none")]
1468    pub certificate: Option<Certificate>,
1469    #[serde(rename = "trustStoreArn")]
1470    #[serde(default)]
1471    #[serde(skip_serializing_if = "Option::is_none")]
1472    pub trust_store_arn: Option<String>,
1473}
1474
1475#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1476pub struct Certificate {
1477    #[serde(default)]
1478    #[serde(skip_serializing_if = "Option::is_none")]
1479    pub body: Option<String>,
1480    #[serde(default)]
1481    #[serde(skip_serializing_if = "Option::is_none")]
1482    pub issuer: Option<String>,
1483    #[serde(rename = "notValidAfter")]
1484    #[serde(default)]
1485    #[serde(skip_serializing_if = "Option::is_none")]
1486    pub not_valid_after: Option<f64>,
1487    #[serde(rename = "notValidBefore")]
1488    #[serde(default)]
1489    #[serde(skip_serializing_if = "Option::is_none")]
1490    pub not_valid_before: Option<f64>,
1491    #[serde(default)]
1492    #[serde(skip_serializing_if = "Option::is_none")]
1493    pub subject: Option<String>,
1494    #[serde(default)]
1495    #[serde(skip_serializing_if = "Option::is_none")]
1496    pub thumbprint: Option<String>,
1497}
1498
1499#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1500pub struct GetTrustStoreRequest {
1501    #[serde(rename = "trustStoreArn")]
1502    #[serde(default)]
1503    pub trust_store_arn: String,
1504}
1505
1506#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1507pub struct GetTrustStoreResponse {
1508    #[serde(rename = "trustStore")]
1509    #[serde(default)]
1510    #[serde(skip_serializing_if = "Option::is_none")]
1511    pub trust_store: Option<TrustStore>,
1512}
1513
1514#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1515pub struct TrustStore {
1516    #[serde(rename = "associatedPortalArns")]
1517    #[serde(default)]
1518    #[serde(skip_serializing_if = "Option::is_none")]
1519    pub associated_portal_arns: Option<Vec<String>>,
1520    #[serde(rename = "trustStoreArn")]
1521    #[serde(default)]
1522    #[serde(skip_serializing_if = "Option::is_none")]
1523    pub trust_store_arn: Option<String>,
1524}
1525
1526#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1527pub struct GetUserAccessLoggingSettingsRequest {
1528    #[serde(rename = "userAccessLoggingSettingsArn")]
1529    #[serde(default)]
1530    pub user_access_logging_settings_arn: String,
1531}
1532
1533#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1534pub struct GetUserAccessLoggingSettingsResponse {
1535    #[serde(rename = "userAccessLoggingSettings")]
1536    #[serde(default)]
1537    #[serde(skip_serializing_if = "Option::is_none")]
1538    pub user_access_logging_settings: Option<UserAccessLoggingSettings>,
1539}
1540
1541#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1542pub struct UserAccessLoggingSettings {
1543    #[serde(rename = "associatedPortalArns")]
1544    #[serde(default)]
1545    #[serde(skip_serializing_if = "Option::is_none")]
1546    pub associated_portal_arns: Option<Vec<String>>,
1547    #[serde(rename = "kinesisStreamArn")]
1548    #[serde(default)]
1549    #[serde(skip_serializing_if = "Option::is_none")]
1550    pub kinesis_stream_arn: Option<String>,
1551    #[serde(rename = "userAccessLoggingSettingsArn")]
1552    #[serde(default)]
1553    #[serde(skip_serializing_if = "Option::is_none")]
1554    pub user_access_logging_settings_arn: Option<String>,
1555}
1556
1557#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1558pub struct GetUserSettingsRequest {
1559    #[serde(rename = "userSettingsArn")]
1560    #[serde(default)]
1561    pub user_settings_arn: String,
1562}
1563
1564#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1565pub struct GetUserSettingsResponse {
1566    #[serde(rename = "userSettings")]
1567    #[serde(default)]
1568    #[serde(skip_serializing_if = "Option::is_none")]
1569    pub user_settings: Option<UserSettings>,
1570}
1571
1572#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1573pub struct UserSettings {
1574    #[serde(rename = "additionalEncryptionContext")]
1575    #[serde(default)]
1576    #[serde(skip_serializing_if = "Option::is_none")]
1577    pub additional_encryption_context: Option<std::collections::HashMap<String, String>>,
1578    #[serde(rename = "associatedPortalArns")]
1579    #[serde(default)]
1580    #[serde(skip_serializing_if = "Option::is_none")]
1581    pub associated_portal_arns: Option<Vec<String>>,
1582    #[serde(rename = "brandingConfiguration")]
1583    #[serde(default)]
1584    #[serde(skip_serializing_if = "Option::is_none")]
1585    pub branding_configuration: Option<BrandingConfiguration>,
1586    #[serde(rename = "cookieSynchronizationConfiguration")]
1587    #[serde(default)]
1588    #[serde(skip_serializing_if = "Option::is_none")]
1589    pub cookie_synchronization_configuration: Option<CookieSynchronizationConfiguration>,
1590    #[serde(rename = "copyAllowed")]
1591    #[serde(default)]
1592    #[serde(skip_serializing_if = "Option::is_none")]
1593    pub copy_allowed: Option<String>,
1594    #[serde(rename = "customerManagedKey")]
1595    #[serde(default)]
1596    #[serde(skip_serializing_if = "Option::is_none")]
1597    pub customer_managed_key: Option<String>,
1598    #[serde(rename = "deepLinkAllowed")]
1599    #[serde(default)]
1600    #[serde(skip_serializing_if = "Option::is_none")]
1601    pub deep_link_allowed: Option<String>,
1602    #[serde(rename = "disconnectTimeoutInMinutes")]
1603    #[serde(default)]
1604    #[serde(skip_serializing_if = "Option::is_none")]
1605    pub disconnect_timeout_in_minutes: Option<i32>,
1606    #[serde(rename = "downloadAllowed")]
1607    #[serde(default)]
1608    #[serde(skip_serializing_if = "Option::is_none")]
1609    pub download_allowed: Option<String>,
1610    #[serde(rename = "idleDisconnectTimeoutInMinutes")]
1611    #[serde(default)]
1612    #[serde(skip_serializing_if = "Option::is_none")]
1613    pub idle_disconnect_timeout_in_minutes: Option<i32>,
1614    #[serde(rename = "pasteAllowed")]
1615    #[serde(default)]
1616    #[serde(skip_serializing_if = "Option::is_none")]
1617    pub paste_allowed: Option<String>,
1618    #[serde(rename = "printAllowed")]
1619    #[serde(default)]
1620    #[serde(skip_serializing_if = "Option::is_none")]
1621    pub print_allowed: Option<String>,
1622    #[serde(rename = "toolbarConfiguration")]
1623    #[serde(default)]
1624    #[serde(skip_serializing_if = "Option::is_none")]
1625    pub toolbar_configuration: Option<ToolbarConfiguration>,
1626    #[serde(rename = "uploadAllowed")]
1627    #[serde(default)]
1628    #[serde(skip_serializing_if = "Option::is_none")]
1629    pub upload_allowed: Option<String>,
1630    #[serde(rename = "userSettingsArn")]
1631    #[serde(default)]
1632    #[serde(skip_serializing_if = "Option::is_none")]
1633    pub user_settings_arn: Option<String>,
1634    #[serde(rename = "webAuthnAllowed")]
1635    #[serde(default)]
1636    #[serde(skip_serializing_if = "Option::is_none")]
1637    pub web_authn_allowed: Option<String>,
1638}
1639
1640#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1641pub struct BrandingConfiguration {
1642    #[serde(rename = "colorTheme")]
1643    #[serde(default)]
1644    #[serde(skip_serializing_if = "Option::is_none")]
1645    pub color_theme: Option<String>,
1646    #[serde(default)]
1647    #[serde(skip_serializing_if = "Option::is_none")]
1648    pub favicon: Option<ImageMetadata>,
1649    #[serde(rename = "localizedStrings")]
1650    #[serde(default)]
1651    #[serde(skip_serializing_if = "Option::is_none")]
1652    pub localized_strings: Option<std::collections::HashMap<String, LocalizedBrandingStrings>>,
1653    #[serde(default)]
1654    #[serde(skip_serializing_if = "Option::is_none")]
1655    pub logo: Option<ImageMetadata>,
1656    #[serde(rename = "termsOfService")]
1657    #[serde(default)]
1658    #[serde(skip_serializing_if = "Option::is_none")]
1659    pub terms_of_service: Option<String>,
1660    #[serde(default)]
1661    #[serde(skip_serializing_if = "Option::is_none")]
1662    pub wallpaper: Option<ImageMetadata>,
1663}
1664
1665#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1666pub struct ImageMetadata {
1667    #[serde(rename = "fileExtension")]
1668    #[serde(default)]
1669    #[serde(skip_serializing_if = "Option::is_none")]
1670    pub file_extension: Option<String>,
1671    #[serde(rename = "lastUploadTimestamp")]
1672    #[serde(default)]
1673    #[serde(skip_serializing_if = "Option::is_none")]
1674    pub last_upload_timestamp: Option<f64>,
1675    #[serde(rename = "mimeType")]
1676    #[serde(default)]
1677    #[serde(skip_serializing_if = "Option::is_none")]
1678    pub mime_type: Option<String>,
1679}
1680
1681#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1682pub struct ListBrowserSettingsRequest {
1683    #[serde(rename = "maxResults")]
1684    #[serde(default)]
1685    #[serde(skip_serializing_if = "Option::is_none")]
1686    pub max_results: Option<i32>,
1687    #[serde(rename = "nextToken")]
1688    #[serde(default)]
1689    #[serde(skip_serializing_if = "Option::is_none")]
1690    pub next_token: Option<String>,
1691}
1692
1693#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1694pub struct ListBrowserSettingsResponse {
1695    #[serde(rename = "browserSettings")]
1696    #[serde(default)]
1697    #[serde(skip_serializing_if = "Option::is_none")]
1698    pub browser_settings: Option<Vec<BrowserSettingsSummary>>,
1699    #[serde(rename = "nextToken")]
1700    #[serde(default)]
1701    #[serde(skip_serializing_if = "Option::is_none")]
1702    pub next_token: Option<String>,
1703}
1704
1705#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1706pub struct BrowserSettingsSummary {
1707    #[serde(rename = "browserSettingsArn")]
1708    #[serde(default)]
1709    #[serde(skip_serializing_if = "Option::is_none")]
1710    pub browser_settings_arn: Option<String>,
1711}
1712
1713#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1714pub struct ListDataProtectionSettingsRequest {
1715    #[serde(rename = "maxResults")]
1716    #[serde(default)]
1717    #[serde(skip_serializing_if = "Option::is_none")]
1718    pub max_results: Option<i32>,
1719    #[serde(rename = "nextToken")]
1720    #[serde(default)]
1721    #[serde(skip_serializing_if = "Option::is_none")]
1722    pub next_token: Option<String>,
1723}
1724
1725#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1726pub struct ListDataProtectionSettingsResponse {
1727    #[serde(rename = "dataProtectionSettings")]
1728    #[serde(default)]
1729    #[serde(skip_serializing_if = "Option::is_none")]
1730    pub data_protection_settings: Option<Vec<DataProtectionSettingsSummary>>,
1731    #[serde(rename = "nextToken")]
1732    #[serde(default)]
1733    #[serde(skip_serializing_if = "Option::is_none")]
1734    pub next_token: Option<String>,
1735}
1736
1737#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1738pub struct DataProtectionSettingsSummary {
1739    #[serde(rename = "creationDate")]
1740    #[serde(default)]
1741    #[serde(skip_serializing_if = "Option::is_none")]
1742    pub creation_date: Option<f64>,
1743    #[serde(rename = "dataProtectionSettingsArn")]
1744    #[serde(default)]
1745    #[serde(skip_serializing_if = "Option::is_none")]
1746    pub data_protection_settings_arn: Option<String>,
1747    #[serde(default)]
1748    #[serde(skip_serializing_if = "Option::is_none")]
1749    pub description: Option<String>,
1750    #[serde(rename = "displayName")]
1751    #[serde(default)]
1752    #[serde(skip_serializing_if = "Option::is_none")]
1753    pub display_name: Option<String>,
1754}
1755
1756#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1757pub struct ListIdentityProvidersRequest {
1758    #[serde(rename = "maxResults")]
1759    #[serde(default)]
1760    #[serde(skip_serializing_if = "Option::is_none")]
1761    pub max_results: Option<i32>,
1762    #[serde(rename = "nextToken")]
1763    #[serde(default)]
1764    #[serde(skip_serializing_if = "Option::is_none")]
1765    pub next_token: Option<String>,
1766    #[serde(rename = "portalArn")]
1767    #[serde(default)]
1768    pub portal_arn: String,
1769}
1770
1771#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1772pub struct ListIdentityProvidersResponse {
1773    #[serde(rename = "identityProviders")]
1774    #[serde(default)]
1775    #[serde(skip_serializing_if = "Option::is_none")]
1776    pub identity_providers: Option<Vec<IdentityProviderSummary>>,
1777    #[serde(rename = "nextToken")]
1778    #[serde(default)]
1779    #[serde(skip_serializing_if = "Option::is_none")]
1780    pub next_token: Option<String>,
1781}
1782
1783#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1784pub struct IdentityProviderSummary {
1785    #[serde(rename = "identityProviderArn")]
1786    #[serde(default)]
1787    #[serde(skip_serializing_if = "Option::is_none")]
1788    pub identity_provider_arn: Option<String>,
1789    #[serde(rename = "identityProviderName")]
1790    #[serde(default)]
1791    #[serde(skip_serializing_if = "Option::is_none")]
1792    pub identity_provider_name: Option<String>,
1793    #[serde(rename = "identityProviderType")]
1794    #[serde(default)]
1795    #[serde(skip_serializing_if = "Option::is_none")]
1796    pub identity_provider_type: Option<String>,
1797}
1798
1799#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1800pub struct ListIpAccessSettingsRequest {
1801    #[serde(rename = "maxResults")]
1802    #[serde(default)]
1803    #[serde(skip_serializing_if = "Option::is_none")]
1804    pub max_results: Option<i32>,
1805    #[serde(rename = "nextToken")]
1806    #[serde(default)]
1807    #[serde(skip_serializing_if = "Option::is_none")]
1808    pub next_token: Option<String>,
1809}
1810
1811#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1812pub struct ListIpAccessSettingsResponse {
1813    #[serde(rename = "ipAccessSettings")]
1814    #[serde(default)]
1815    #[serde(skip_serializing_if = "Option::is_none")]
1816    pub ip_access_settings: Option<Vec<IpAccessSettingsSummary>>,
1817    #[serde(rename = "nextToken")]
1818    #[serde(default)]
1819    #[serde(skip_serializing_if = "Option::is_none")]
1820    pub next_token: Option<String>,
1821}
1822
1823#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1824pub struct IpAccessSettingsSummary {
1825    #[serde(rename = "creationDate")]
1826    #[serde(default)]
1827    #[serde(skip_serializing_if = "Option::is_none")]
1828    pub creation_date: Option<f64>,
1829    #[serde(default)]
1830    #[serde(skip_serializing_if = "Option::is_none")]
1831    pub description: Option<String>,
1832    #[serde(rename = "displayName")]
1833    #[serde(default)]
1834    #[serde(skip_serializing_if = "Option::is_none")]
1835    pub display_name: Option<String>,
1836    #[serde(rename = "ipAccessSettingsArn")]
1837    #[serde(default)]
1838    #[serde(skip_serializing_if = "Option::is_none")]
1839    pub ip_access_settings_arn: Option<String>,
1840}
1841
1842#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1843pub struct ListNetworkSettingsRequest {
1844    #[serde(rename = "maxResults")]
1845    #[serde(default)]
1846    #[serde(skip_serializing_if = "Option::is_none")]
1847    pub max_results: Option<i32>,
1848    #[serde(rename = "nextToken")]
1849    #[serde(default)]
1850    #[serde(skip_serializing_if = "Option::is_none")]
1851    pub next_token: Option<String>,
1852}
1853
1854#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1855pub struct ListNetworkSettingsResponse {
1856    #[serde(rename = "networkSettings")]
1857    #[serde(default)]
1858    #[serde(skip_serializing_if = "Option::is_none")]
1859    pub network_settings: Option<Vec<NetworkSettingsSummary>>,
1860    #[serde(rename = "nextToken")]
1861    #[serde(default)]
1862    #[serde(skip_serializing_if = "Option::is_none")]
1863    pub next_token: Option<String>,
1864}
1865
1866#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1867pub struct NetworkSettingsSummary {
1868    #[serde(rename = "networkSettingsArn")]
1869    #[serde(default)]
1870    #[serde(skip_serializing_if = "Option::is_none")]
1871    pub network_settings_arn: Option<String>,
1872    #[serde(rename = "vpcId")]
1873    #[serde(default)]
1874    #[serde(skip_serializing_if = "Option::is_none")]
1875    pub vpc_id: Option<String>,
1876}
1877
1878#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1879pub struct ListPortalsRequest {
1880    #[serde(rename = "maxResults")]
1881    #[serde(default)]
1882    #[serde(skip_serializing_if = "Option::is_none")]
1883    pub max_results: Option<i32>,
1884    #[serde(rename = "nextToken")]
1885    #[serde(default)]
1886    #[serde(skip_serializing_if = "Option::is_none")]
1887    pub next_token: Option<String>,
1888}
1889
1890#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1891pub struct ListPortalsResponse {
1892    #[serde(rename = "nextToken")]
1893    #[serde(default)]
1894    #[serde(skip_serializing_if = "Option::is_none")]
1895    pub next_token: Option<String>,
1896    #[serde(default)]
1897    #[serde(skip_serializing_if = "Option::is_none")]
1898    pub portals: Option<Vec<PortalSummary>>,
1899}
1900
1901#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1902pub struct PortalSummary {
1903    #[serde(rename = "authenticationType")]
1904    #[serde(default)]
1905    #[serde(skip_serializing_if = "Option::is_none")]
1906    pub authentication_type: Option<String>,
1907    #[serde(rename = "browserSettingsArn")]
1908    #[serde(default)]
1909    #[serde(skip_serializing_if = "Option::is_none")]
1910    pub browser_settings_arn: Option<String>,
1911    #[serde(rename = "browserType")]
1912    #[serde(default)]
1913    #[serde(skip_serializing_if = "Option::is_none")]
1914    pub browser_type: Option<String>,
1915    #[serde(rename = "creationDate")]
1916    #[serde(default)]
1917    #[serde(skip_serializing_if = "Option::is_none")]
1918    pub creation_date: Option<f64>,
1919    #[serde(rename = "dataProtectionSettingsArn")]
1920    #[serde(default)]
1921    #[serde(skip_serializing_if = "Option::is_none")]
1922    pub data_protection_settings_arn: Option<String>,
1923    #[serde(rename = "displayName")]
1924    #[serde(default)]
1925    #[serde(skip_serializing_if = "Option::is_none")]
1926    pub display_name: Option<String>,
1927    #[serde(rename = "instanceType")]
1928    #[serde(default)]
1929    #[serde(skip_serializing_if = "Option::is_none")]
1930    pub instance_type: Option<String>,
1931    #[serde(rename = "ipAccessSettingsArn")]
1932    #[serde(default)]
1933    #[serde(skip_serializing_if = "Option::is_none")]
1934    pub ip_access_settings_arn: Option<String>,
1935    #[serde(rename = "maxConcurrentSessions")]
1936    #[serde(default)]
1937    #[serde(skip_serializing_if = "Option::is_none")]
1938    pub max_concurrent_sessions: Option<i32>,
1939    #[serde(rename = "networkSettingsArn")]
1940    #[serde(default)]
1941    #[serde(skip_serializing_if = "Option::is_none")]
1942    pub network_settings_arn: Option<String>,
1943    #[serde(rename = "portalArn")]
1944    #[serde(default)]
1945    #[serde(skip_serializing_if = "Option::is_none")]
1946    pub portal_arn: Option<String>,
1947    #[serde(rename = "portalCustomDomain")]
1948    #[serde(default)]
1949    #[serde(skip_serializing_if = "Option::is_none")]
1950    pub portal_custom_domain: Option<String>,
1951    #[serde(rename = "portalEndpoint")]
1952    #[serde(default)]
1953    #[serde(skip_serializing_if = "Option::is_none")]
1954    pub portal_endpoint: Option<String>,
1955    #[serde(rename = "portalStatus")]
1956    #[serde(default)]
1957    #[serde(skip_serializing_if = "Option::is_none")]
1958    pub portal_status: Option<String>,
1959    #[serde(rename = "rendererType")]
1960    #[serde(default)]
1961    #[serde(skip_serializing_if = "Option::is_none")]
1962    pub renderer_type: Option<String>,
1963    #[serde(rename = "sessionLoggerArn")]
1964    #[serde(default)]
1965    #[serde(skip_serializing_if = "Option::is_none")]
1966    pub session_logger_arn: Option<String>,
1967    #[serde(rename = "trustStoreArn")]
1968    #[serde(default)]
1969    #[serde(skip_serializing_if = "Option::is_none")]
1970    pub trust_store_arn: Option<String>,
1971    #[serde(rename = "userAccessLoggingSettingsArn")]
1972    #[serde(default)]
1973    #[serde(skip_serializing_if = "Option::is_none")]
1974    pub user_access_logging_settings_arn: Option<String>,
1975    #[serde(rename = "userSettingsArn")]
1976    #[serde(default)]
1977    #[serde(skip_serializing_if = "Option::is_none")]
1978    pub user_settings_arn: Option<String>,
1979}
1980
1981#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1982pub struct ListSessionLoggersRequest {
1983    #[serde(rename = "maxResults")]
1984    #[serde(default)]
1985    #[serde(skip_serializing_if = "Option::is_none")]
1986    pub max_results: Option<i32>,
1987    #[serde(rename = "nextToken")]
1988    #[serde(default)]
1989    #[serde(skip_serializing_if = "Option::is_none")]
1990    pub next_token: Option<String>,
1991}
1992
1993#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1994pub struct ListSessionLoggersResponse {
1995    #[serde(rename = "nextToken")]
1996    #[serde(default)]
1997    #[serde(skip_serializing_if = "Option::is_none")]
1998    pub next_token: Option<String>,
1999    #[serde(rename = "sessionLoggers")]
2000    #[serde(default)]
2001    #[serde(skip_serializing_if = "Option::is_none")]
2002    pub session_loggers: Option<Vec<SessionLoggerSummary>>,
2003}
2004
2005#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2006pub struct SessionLoggerSummary {
2007    #[serde(rename = "creationDate")]
2008    #[serde(default)]
2009    #[serde(skip_serializing_if = "Option::is_none")]
2010    pub creation_date: Option<f64>,
2011    #[serde(rename = "displayName")]
2012    #[serde(default)]
2013    #[serde(skip_serializing_if = "Option::is_none")]
2014    pub display_name: Option<String>,
2015    #[serde(rename = "logConfiguration")]
2016    #[serde(default)]
2017    #[serde(skip_serializing_if = "Option::is_none")]
2018    pub log_configuration: Option<LogConfiguration>,
2019    #[serde(rename = "sessionLoggerArn")]
2020    #[serde(default)]
2021    #[serde(skip_serializing_if = "Option::is_none")]
2022    pub session_logger_arn: Option<String>,
2023}
2024
2025#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2026pub struct ListSessionsRequest {
2027    #[serde(rename = "maxResults")]
2028    #[serde(default)]
2029    #[serde(skip_serializing_if = "Option::is_none")]
2030    pub max_results: Option<i32>,
2031    #[serde(rename = "nextToken")]
2032    #[serde(default)]
2033    #[serde(skip_serializing_if = "Option::is_none")]
2034    pub next_token: Option<String>,
2035    #[serde(rename = "portalId")]
2036    #[serde(default)]
2037    pub portal_id: String,
2038    #[serde(rename = "sessionId")]
2039    #[serde(default)]
2040    #[serde(skip_serializing_if = "Option::is_none")]
2041    pub session_id: Option<String>,
2042    #[serde(rename = "sortBy")]
2043    #[serde(default)]
2044    #[serde(skip_serializing_if = "Option::is_none")]
2045    pub sort_by: Option<String>,
2046    #[serde(default)]
2047    #[serde(skip_serializing_if = "Option::is_none")]
2048    pub status: Option<String>,
2049    #[serde(default)]
2050    #[serde(skip_serializing_if = "Option::is_none")]
2051    pub username: Option<String>,
2052}
2053
2054#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2055pub struct ListSessionsResponse {
2056    #[serde(rename = "nextToken")]
2057    #[serde(default)]
2058    #[serde(skip_serializing_if = "Option::is_none")]
2059    pub next_token: Option<String>,
2060    #[serde(default)]
2061    #[serde(skip_serializing_if = "Option::is_none")]
2062    pub sessions: Option<Vec<SessionSummary>>,
2063}
2064
2065#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2066pub struct SessionSummary {
2067    #[serde(rename = "endTime")]
2068    #[serde(default)]
2069    #[serde(skip_serializing_if = "Option::is_none")]
2070    pub end_time: Option<f64>,
2071    #[serde(rename = "portalArn")]
2072    #[serde(default)]
2073    #[serde(skip_serializing_if = "Option::is_none")]
2074    pub portal_arn: Option<String>,
2075    #[serde(rename = "sessionId")]
2076    #[serde(default)]
2077    #[serde(skip_serializing_if = "Option::is_none")]
2078    pub session_id: Option<String>,
2079    #[serde(rename = "startTime")]
2080    #[serde(default)]
2081    #[serde(skip_serializing_if = "Option::is_none")]
2082    pub start_time: Option<f64>,
2083    #[serde(default)]
2084    #[serde(skip_serializing_if = "Option::is_none")]
2085    pub status: Option<String>,
2086    #[serde(default)]
2087    #[serde(skip_serializing_if = "Option::is_none")]
2088    pub username: Option<String>,
2089}
2090
2091#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2092pub struct ListTagsForResourceRequest {
2093    #[serde(rename = "resourceArn")]
2094    #[serde(default)]
2095    pub resource_arn: String,
2096}
2097
2098#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2099pub struct ListTagsForResourceResponse {
2100    #[serde(default)]
2101    #[serde(skip_serializing_if = "Option::is_none")]
2102    pub tags: Option<Vec<Tag>>,
2103}
2104
2105#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2106pub struct ListTrustStoreCertificatesRequest {
2107    #[serde(rename = "maxResults")]
2108    #[serde(default)]
2109    #[serde(skip_serializing_if = "Option::is_none")]
2110    pub max_results: Option<i32>,
2111    #[serde(rename = "nextToken")]
2112    #[serde(default)]
2113    #[serde(skip_serializing_if = "Option::is_none")]
2114    pub next_token: Option<String>,
2115    #[serde(rename = "trustStoreArn")]
2116    #[serde(default)]
2117    pub trust_store_arn: String,
2118}
2119
2120#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2121pub struct ListTrustStoreCertificatesResponse {
2122    #[serde(rename = "certificateList")]
2123    #[serde(default)]
2124    #[serde(skip_serializing_if = "Option::is_none")]
2125    pub certificate_list: Option<Vec<CertificateSummary>>,
2126    #[serde(rename = "nextToken")]
2127    #[serde(default)]
2128    #[serde(skip_serializing_if = "Option::is_none")]
2129    pub next_token: Option<String>,
2130    #[serde(rename = "trustStoreArn")]
2131    #[serde(default)]
2132    #[serde(skip_serializing_if = "Option::is_none")]
2133    pub trust_store_arn: Option<String>,
2134}
2135
2136#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2137pub struct CertificateSummary {
2138    #[serde(default)]
2139    #[serde(skip_serializing_if = "Option::is_none")]
2140    pub issuer: Option<String>,
2141    #[serde(rename = "notValidAfter")]
2142    #[serde(default)]
2143    #[serde(skip_serializing_if = "Option::is_none")]
2144    pub not_valid_after: Option<f64>,
2145    #[serde(rename = "notValidBefore")]
2146    #[serde(default)]
2147    #[serde(skip_serializing_if = "Option::is_none")]
2148    pub not_valid_before: Option<f64>,
2149    #[serde(default)]
2150    #[serde(skip_serializing_if = "Option::is_none")]
2151    pub subject: Option<String>,
2152    #[serde(default)]
2153    #[serde(skip_serializing_if = "Option::is_none")]
2154    pub thumbprint: Option<String>,
2155}
2156
2157#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2158pub struct ListTrustStoresRequest {
2159    #[serde(rename = "maxResults")]
2160    #[serde(default)]
2161    #[serde(skip_serializing_if = "Option::is_none")]
2162    pub max_results: Option<i32>,
2163    #[serde(rename = "nextToken")]
2164    #[serde(default)]
2165    #[serde(skip_serializing_if = "Option::is_none")]
2166    pub next_token: Option<String>,
2167}
2168
2169#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2170pub struct ListTrustStoresResponse {
2171    #[serde(rename = "nextToken")]
2172    #[serde(default)]
2173    #[serde(skip_serializing_if = "Option::is_none")]
2174    pub next_token: Option<String>,
2175    #[serde(rename = "trustStores")]
2176    #[serde(default)]
2177    #[serde(skip_serializing_if = "Option::is_none")]
2178    pub trust_stores: Option<Vec<TrustStoreSummary>>,
2179}
2180
2181#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2182pub struct TrustStoreSummary {
2183    #[serde(rename = "trustStoreArn")]
2184    #[serde(default)]
2185    #[serde(skip_serializing_if = "Option::is_none")]
2186    pub trust_store_arn: Option<String>,
2187}
2188
2189#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2190pub struct ListUserAccessLoggingSettingsRequest {
2191    #[serde(rename = "maxResults")]
2192    #[serde(default)]
2193    #[serde(skip_serializing_if = "Option::is_none")]
2194    pub max_results: Option<i32>,
2195    #[serde(rename = "nextToken")]
2196    #[serde(default)]
2197    #[serde(skip_serializing_if = "Option::is_none")]
2198    pub next_token: Option<String>,
2199}
2200
2201#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2202pub struct ListUserAccessLoggingSettingsResponse {
2203    #[serde(rename = "nextToken")]
2204    #[serde(default)]
2205    #[serde(skip_serializing_if = "Option::is_none")]
2206    pub next_token: Option<String>,
2207    #[serde(rename = "userAccessLoggingSettings")]
2208    #[serde(default)]
2209    #[serde(skip_serializing_if = "Option::is_none")]
2210    pub user_access_logging_settings: Option<Vec<UserAccessLoggingSettingsSummary>>,
2211}
2212
2213#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2214pub struct UserAccessLoggingSettingsSummary {
2215    #[serde(rename = "kinesisStreamArn")]
2216    #[serde(default)]
2217    #[serde(skip_serializing_if = "Option::is_none")]
2218    pub kinesis_stream_arn: Option<String>,
2219    #[serde(rename = "userAccessLoggingSettingsArn")]
2220    #[serde(default)]
2221    #[serde(skip_serializing_if = "Option::is_none")]
2222    pub user_access_logging_settings_arn: Option<String>,
2223}
2224
2225#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2226pub struct ListUserSettingsRequest {
2227    #[serde(rename = "maxResults")]
2228    #[serde(default)]
2229    #[serde(skip_serializing_if = "Option::is_none")]
2230    pub max_results: Option<i32>,
2231    #[serde(rename = "nextToken")]
2232    #[serde(default)]
2233    #[serde(skip_serializing_if = "Option::is_none")]
2234    pub next_token: Option<String>,
2235}
2236
2237#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2238pub struct ListUserSettingsResponse {
2239    #[serde(rename = "nextToken")]
2240    #[serde(default)]
2241    #[serde(skip_serializing_if = "Option::is_none")]
2242    pub next_token: Option<String>,
2243    #[serde(rename = "userSettings")]
2244    #[serde(default)]
2245    #[serde(skip_serializing_if = "Option::is_none")]
2246    pub user_settings: Option<Vec<UserSettingsSummary>>,
2247}
2248
2249#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2250pub struct UserSettingsSummary {
2251    #[serde(rename = "brandingConfiguration")]
2252    #[serde(default)]
2253    #[serde(skip_serializing_if = "Option::is_none")]
2254    pub branding_configuration: Option<BrandingConfiguration>,
2255    #[serde(rename = "cookieSynchronizationConfiguration")]
2256    #[serde(default)]
2257    #[serde(skip_serializing_if = "Option::is_none")]
2258    pub cookie_synchronization_configuration: Option<CookieSynchronizationConfiguration>,
2259    #[serde(rename = "copyAllowed")]
2260    #[serde(default)]
2261    #[serde(skip_serializing_if = "Option::is_none")]
2262    pub copy_allowed: Option<String>,
2263    #[serde(rename = "deepLinkAllowed")]
2264    #[serde(default)]
2265    #[serde(skip_serializing_if = "Option::is_none")]
2266    pub deep_link_allowed: Option<String>,
2267    #[serde(rename = "disconnectTimeoutInMinutes")]
2268    #[serde(default)]
2269    #[serde(skip_serializing_if = "Option::is_none")]
2270    pub disconnect_timeout_in_minutes: Option<i32>,
2271    #[serde(rename = "downloadAllowed")]
2272    #[serde(default)]
2273    #[serde(skip_serializing_if = "Option::is_none")]
2274    pub download_allowed: Option<String>,
2275    #[serde(rename = "idleDisconnectTimeoutInMinutes")]
2276    #[serde(default)]
2277    #[serde(skip_serializing_if = "Option::is_none")]
2278    pub idle_disconnect_timeout_in_minutes: Option<i32>,
2279    #[serde(rename = "pasteAllowed")]
2280    #[serde(default)]
2281    #[serde(skip_serializing_if = "Option::is_none")]
2282    pub paste_allowed: Option<String>,
2283    #[serde(rename = "printAllowed")]
2284    #[serde(default)]
2285    #[serde(skip_serializing_if = "Option::is_none")]
2286    pub print_allowed: Option<String>,
2287    #[serde(rename = "toolbarConfiguration")]
2288    #[serde(default)]
2289    #[serde(skip_serializing_if = "Option::is_none")]
2290    pub toolbar_configuration: Option<ToolbarConfiguration>,
2291    #[serde(rename = "uploadAllowed")]
2292    #[serde(default)]
2293    #[serde(skip_serializing_if = "Option::is_none")]
2294    pub upload_allowed: Option<String>,
2295    #[serde(rename = "userSettingsArn")]
2296    #[serde(default)]
2297    #[serde(skip_serializing_if = "Option::is_none")]
2298    pub user_settings_arn: Option<String>,
2299    #[serde(rename = "webAuthnAllowed")]
2300    #[serde(default)]
2301    #[serde(skip_serializing_if = "Option::is_none")]
2302    pub web_authn_allowed: Option<String>,
2303}
2304
2305#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2306pub struct TagResourceRequest {
2307    #[serde(rename = "clientToken")]
2308    #[serde(default)]
2309    #[serde(skip_serializing_if = "Option::is_none")]
2310    pub client_token: Option<String>,
2311    #[serde(rename = "resourceArn")]
2312    #[serde(default)]
2313    pub resource_arn: String,
2314    #[serde(default)]
2315    pub tags: Vec<Tag>,
2316}
2317
2318#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2319pub struct TagResourceResponse {}
2320
2321#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2322pub struct UntagResourceRequest {
2323    #[serde(rename = "resourceArn")]
2324    #[serde(default)]
2325    pub resource_arn: String,
2326    #[serde(rename = "tagKeys")]
2327    #[serde(default)]
2328    pub tag_keys: Vec<String>,
2329}
2330
2331#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2332pub struct UntagResourceResponse {}
2333
2334#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2335pub struct UpdateBrowserSettingsRequest {
2336    #[serde(rename = "browserPolicy")]
2337    #[serde(default)]
2338    #[serde(skip_serializing_if = "Option::is_none")]
2339    pub browser_policy: Option<String>,
2340    #[serde(rename = "browserSettingsArn")]
2341    #[serde(default)]
2342    pub browser_settings_arn: String,
2343    #[serde(rename = "clientToken")]
2344    #[serde(default)]
2345    #[serde(skip_serializing_if = "Option::is_none")]
2346    pub client_token: Option<String>,
2347    #[serde(rename = "webContentFilteringPolicy")]
2348    #[serde(default)]
2349    #[serde(skip_serializing_if = "Option::is_none")]
2350    pub web_content_filtering_policy: Option<WebContentFilteringPolicy>,
2351}
2352
2353#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2354pub struct UpdateBrowserSettingsResponse {
2355    #[serde(rename = "browserSettings")]
2356    #[serde(default)]
2357    #[serde(skip_serializing_if = "Option::is_none")]
2358    pub browser_settings: Option<BrowserSettings>,
2359}
2360
2361#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2362pub struct UpdateDataProtectionSettingsRequest {
2363    #[serde(rename = "clientToken")]
2364    #[serde(default)]
2365    #[serde(skip_serializing_if = "Option::is_none")]
2366    pub client_token: Option<String>,
2367    #[serde(rename = "dataProtectionSettingsArn")]
2368    #[serde(default)]
2369    pub data_protection_settings_arn: String,
2370    #[serde(default)]
2371    #[serde(skip_serializing_if = "Option::is_none")]
2372    pub description: Option<String>,
2373    #[serde(rename = "displayName")]
2374    #[serde(default)]
2375    #[serde(skip_serializing_if = "Option::is_none")]
2376    pub display_name: Option<String>,
2377    #[serde(rename = "inlineRedactionConfiguration")]
2378    #[serde(default)]
2379    #[serde(skip_serializing_if = "Option::is_none")]
2380    pub inline_redaction_configuration: Option<InlineRedactionConfiguration>,
2381}
2382
2383#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2384pub struct UpdateDataProtectionSettingsResponse {
2385    #[serde(rename = "dataProtectionSettings")]
2386    #[serde(default)]
2387    #[serde(skip_serializing_if = "Option::is_none")]
2388    pub data_protection_settings: Option<DataProtectionSettings>,
2389}
2390
2391#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2392pub struct UpdateIdentityProviderRequest {
2393    #[serde(rename = "clientToken")]
2394    #[serde(default)]
2395    #[serde(skip_serializing_if = "Option::is_none")]
2396    pub client_token: Option<String>,
2397    #[serde(rename = "identityProviderArn")]
2398    #[serde(default)]
2399    pub identity_provider_arn: String,
2400    #[serde(rename = "identityProviderDetails")]
2401    #[serde(default)]
2402    #[serde(skip_serializing_if = "Option::is_none")]
2403    pub identity_provider_details: Option<std::collections::HashMap<String, String>>,
2404    #[serde(rename = "identityProviderName")]
2405    #[serde(default)]
2406    #[serde(skip_serializing_if = "Option::is_none")]
2407    pub identity_provider_name: Option<String>,
2408    #[serde(rename = "identityProviderType")]
2409    #[serde(default)]
2410    #[serde(skip_serializing_if = "Option::is_none")]
2411    pub identity_provider_type: Option<String>,
2412}
2413
2414#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2415pub struct UpdateIdentityProviderResponse {
2416    #[serde(rename = "identityProvider")]
2417    #[serde(default)]
2418    #[serde(skip_serializing_if = "Option::is_none")]
2419    pub identity_provider: Option<IdentityProvider>,
2420}
2421
2422#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2423pub struct UpdateIpAccessSettingsRequest {
2424    #[serde(rename = "clientToken")]
2425    #[serde(default)]
2426    #[serde(skip_serializing_if = "Option::is_none")]
2427    pub client_token: Option<String>,
2428    #[serde(default)]
2429    #[serde(skip_serializing_if = "Option::is_none")]
2430    pub description: Option<String>,
2431    #[serde(rename = "displayName")]
2432    #[serde(default)]
2433    #[serde(skip_serializing_if = "Option::is_none")]
2434    pub display_name: Option<String>,
2435    #[serde(rename = "ipAccessSettingsArn")]
2436    #[serde(default)]
2437    pub ip_access_settings_arn: String,
2438    #[serde(rename = "ipRules")]
2439    #[serde(default)]
2440    #[serde(skip_serializing_if = "Option::is_none")]
2441    pub ip_rules: Option<Vec<IpRule>>,
2442}
2443
2444#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2445pub struct UpdateIpAccessSettingsResponse {
2446    #[serde(rename = "ipAccessSettings")]
2447    #[serde(default)]
2448    #[serde(skip_serializing_if = "Option::is_none")]
2449    pub ip_access_settings: Option<IpAccessSettings>,
2450}
2451
2452#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2453pub struct UpdateNetworkSettingsRequest {
2454    #[serde(rename = "clientToken")]
2455    #[serde(default)]
2456    #[serde(skip_serializing_if = "Option::is_none")]
2457    pub client_token: Option<String>,
2458    #[serde(rename = "networkSettingsArn")]
2459    #[serde(default)]
2460    pub network_settings_arn: String,
2461    #[serde(rename = "securityGroupIds")]
2462    #[serde(default)]
2463    #[serde(skip_serializing_if = "Option::is_none")]
2464    pub security_group_ids: Option<Vec<String>>,
2465    #[serde(rename = "subnetIds")]
2466    #[serde(default)]
2467    #[serde(skip_serializing_if = "Option::is_none")]
2468    pub subnet_ids: Option<Vec<String>>,
2469    #[serde(rename = "vpcId")]
2470    #[serde(default)]
2471    #[serde(skip_serializing_if = "Option::is_none")]
2472    pub vpc_id: Option<String>,
2473}
2474
2475#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2476pub struct UpdateNetworkSettingsResponse {
2477    #[serde(rename = "networkSettings")]
2478    #[serde(default)]
2479    #[serde(skip_serializing_if = "Option::is_none")]
2480    pub network_settings: Option<NetworkSettings>,
2481}
2482
2483#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2484pub struct UpdatePortalRequest {
2485    #[serde(rename = "authenticationType")]
2486    #[serde(default)]
2487    #[serde(skip_serializing_if = "Option::is_none")]
2488    pub authentication_type: Option<String>,
2489    #[serde(rename = "displayName")]
2490    #[serde(default)]
2491    #[serde(skip_serializing_if = "Option::is_none")]
2492    pub display_name: Option<String>,
2493    #[serde(rename = "instanceType")]
2494    #[serde(default)]
2495    #[serde(skip_serializing_if = "Option::is_none")]
2496    pub instance_type: Option<String>,
2497    #[serde(rename = "maxConcurrentSessions")]
2498    #[serde(default)]
2499    #[serde(skip_serializing_if = "Option::is_none")]
2500    pub max_concurrent_sessions: Option<i32>,
2501    #[serde(rename = "portalArn")]
2502    #[serde(default)]
2503    pub portal_arn: String,
2504    #[serde(rename = "portalCustomDomain")]
2505    #[serde(default)]
2506    #[serde(skip_serializing_if = "Option::is_none")]
2507    pub portal_custom_domain: Option<String>,
2508}
2509
2510#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2511pub struct UpdatePortalResponse {
2512    #[serde(default)]
2513    #[serde(skip_serializing_if = "Option::is_none")]
2514    pub portal: Option<Portal>,
2515}
2516
2517#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2518pub struct UpdateSessionLoggerRequest {
2519    #[serde(rename = "displayName")]
2520    #[serde(default)]
2521    #[serde(skip_serializing_if = "Option::is_none")]
2522    pub display_name: Option<String>,
2523    #[serde(rename = "eventFilter")]
2524    #[serde(default)]
2525    #[serde(skip_serializing_if = "Option::is_none")]
2526    pub event_filter: Option<EventFilter>,
2527    #[serde(rename = "logConfiguration")]
2528    #[serde(default)]
2529    #[serde(skip_serializing_if = "Option::is_none")]
2530    pub log_configuration: Option<LogConfiguration>,
2531    #[serde(rename = "sessionLoggerArn")]
2532    #[serde(default)]
2533    pub session_logger_arn: String,
2534}
2535
2536#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2537pub struct UpdateSessionLoggerResponse {
2538    #[serde(rename = "sessionLogger")]
2539    #[serde(default)]
2540    #[serde(skip_serializing_if = "Option::is_none")]
2541    pub session_logger: Option<SessionLogger>,
2542}
2543
2544#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2545pub struct UpdateTrustStoreRequest {
2546    #[serde(rename = "certificatesToAdd")]
2547    #[serde(default)]
2548    #[serde(skip_serializing_if = "Option::is_none")]
2549    pub certificates_to_add: Option<Vec<String>>,
2550    #[serde(rename = "certificatesToDelete")]
2551    #[serde(default)]
2552    #[serde(skip_serializing_if = "Option::is_none")]
2553    pub certificates_to_delete: Option<Vec<String>>,
2554    #[serde(rename = "clientToken")]
2555    #[serde(default)]
2556    #[serde(skip_serializing_if = "Option::is_none")]
2557    pub client_token: Option<String>,
2558    #[serde(rename = "trustStoreArn")]
2559    #[serde(default)]
2560    pub trust_store_arn: String,
2561}
2562
2563#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2564pub struct UpdateTrustStoreResponse {
2565    #[serde(rename = "trustStoreArn")]
2566    #[serde(default)]
2567    #[serde(skip_serializing_if = "Option::is_none")]
2568    pub trust_store_arn: Option<String>,
2569}
2570
2571#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2572pub struct UpdateUserAccessLoggingSettingsRequest {
2573    #[serde(rename = "clientToken")]
2574    #[serde(default)]
2575    #[serde(skip_serializing_if = "Option::is_none")]
2576    pub client_token: Option<String>,
2577    #[serde(rename = "kinesisStreamArn")]
2578    #[serde(default)]
2579    #[serde(skip_serializing_if = "Option::is_none")]
2580    pub kinesis_stream_arn: Option<String>,
2581    #[serde(rename = "userAccessLoggingSettingsArn")]
2582    #[serde(default)]
2583    pub user_access_logging_settings_arn: String,
2584}
2585
2586#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2587pub struct UpdateUserAccessLoggingSettingsResponse {
2588    #[serde(rename = "userAccessLoggingSettings")]
2589    #[serde(default)]
2590    #[serde(skip_serializing_if = "Option::is_none")]
2591    pub user_access_logging_settings: Option<UserAccessLoggingSettings>,
2592}
2593
2594#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2595pub struct UpdateUserSettingsRequest {
2596    #[serde(rename = "brandingConfigurationInput")]
2597    #[serde(default)]
2598    #[serde(skip_serializing_if = "Option::is_none")]
2599    pub branding_configuration_input: Option<BrandingConfigurationUpdateInput>,
2600    #[serde(rename = "clientToken")]
2601    #[serde(default)]
2602    #[serde(skip_serializing_if = "Option::is_none")]
2603    pub client_token: Option<String>,
2604    #[serde(rename = "cookieSynchronizationConfiguration")]
2605    #[serde(default)]
2606    #[serde(skip_serializing_if = "Option::is_none")]
2607    pub cookie_synchronization_configuration: Option<CookieSynchronizationConfiguration>,
2608    #[serde(rename = "copyAllowed")]
2609    #[serde(default)]
2610    #[serde(skip_serializing_if = "Option::is_none")]
2611    pub copy_allowed: Option<String>,
2612    #[serde(rename = "deepLinkAllowed")]
2613    #[serde(default)]
2614    #[serde(skip_serializing_if = "Option::is_none")]
2615    pub deep_link_allowed: Option<String>,
2616    #[serde(rename = "disconnectTimeoutInMinutes")]
2617    #[serde(default)]
2618    #[serde(skip_serializing_if = "Option::is_none")]
2619    pub disconnect_timeout_in_minutes: Option<i32>,
2620    #[serde(rename = "downloadAllowed")]
2621    #[serde(default)]
2622    #[serde(skip_serializing_if = "Option::is_none")]
2623    pub download_allowed: Option<String>,
2624    #[serde(rename = "idleDisconnectTimeoutInMinutes")]
2625    #[serde(default)]
2626    #[serde(skip_serializing_if = "Option::is_none")]
2627    pub idle_disconnect_timeout_in_minutes: Option<i32>,
2628    #[serde(rename = "pasteAllowed")]
2629    #[serde(default)]
2630    #[serde(skip_serializing_if = "Option::is_none")]
2631    pub paste_allowed: Option<String>,
2632    #[serde(rename = "printAllowed")]
2633    #[serde(default)]
2634    #[serde(skip_serializing_if = "Option::is_none")]
2635    pub print_allowed: Option<String>,
2636    #[serde(rename = "toolbarConfiguration")]
2637    #[serde(default)]
2638    #[serde(skip_serializing_if = "Option::is_none")]
2639    pub toolbar_configuration: Option<ToolbarConfiguration>,
2640    #[serde(rename = "uploadAllowed")]
2641    #[serde(default)]
2642    #[serde(skip_serializing_if = "Option::is_none")]
2643    pub upload_allowed: Option<String>,
2644    #[serde(rename = "userSettingsArn")]
2645    #[serde(default)]
2646    pub user_settings_arn: String,
2647    #[serde(rename = "webAuthnAllowed")]
2648    #[serde(default)]
2649    #[serde(skip_serializing_if = "Option::is_none")]
2650    pub web_authn_allowed: Option<String>,
2651}
2652
2653#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2654pub struct BrandingConfigurationUpdateInput {
2655    #[serde(rename = "colorTheme")]
2656    #[serde(default)]
2657    #[serde(skip_serializing_if = "Option::is_none")]
2658    pub color_theme: Option<String>,
2659    #[serde(default)]
2660    #[serde(skip_serializing_if = "Option::is_none")]
2661    pub favicon: Option<IconImageInput>,
2662    #[serde(rename = "localizedStrings")]
2663    #[serde(default)]
2664    #[serde(skip_serializing_if = "Option::is_none")]
2665    pub localized_strings: Option<std::collections::HashMap<String, LocalizedBrandingStrings>>,
2666    #[serde(default)]
2667    #[serde(skip_serializing_if = "Option::is_none")]
2668    pub logo: Option<IconImageInput>,
2669    #[serde(rename = "termsOfService")]
2670    #[serde(default)]
2671    #[serde(skip_serializing_if = "Option::is_none")]
2672    pub terms_of_service: Option<String>,
2673    #[serde(default)]
2674    #[serde(skip_serializing_if = "Option::is_none")]
2675    pub wallpaper: Option<WallpaperImageInput>,
2676}
2677
2678#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2679pub struct UpdateUserSettingsResponse {
2680    #[serde(rename = "userSettings")]
2681    #[serde(default)]
2682    #[serde(skip_serializing_if = "Option::is_none")]
2683    pub user_settings: Option<UserSettings>,
2684}