Skip to main content

winterbaume_workspaces/
model.rs

1//! Auto-generated types from Smithy models.
2//! Do not edit manually. Regenerate with:
3//!   smithy-codegen gen-serializers winterbaume-workspaces
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 AcceptAccountLinkInvitationRequest {
11    #[serde(rename = "ClientToken")]
12    #[serde(default)]
13    #[serde(skip_serializing_if = "Option::is_none")]
14    pub client_token: Option<String>,
15    #[serde(rename = "LinkId")]
16    #[serde(default)]
17    pub link_id: String,
18}
19
20#[derive(Debug, Clone, Default, Deserialize, Serialize)]
21pub struct AcceptAccountLinkInvitationResult {
22    #[serde(rename = "AccountLink")]
23    #[serde(default)]
24    #[serde(skip_serializing_if = "Option::is_none")]
25    pub account_link: Option<AccountLink>,
26}
27
28#[derive(Debug, Clone, Default, Deserialize, Serialize)]
29pub struct AccountLink {
30    #[serde(rename = "AccountLinkId")]
31    #[serde(default)]
32    #[serde(skip_serializing_if = "Option::is_none")]
33    pub account_link_id: Option<String>,
34    #[serde(rename = "AccountLinkStatus")]
35    #[serde(default)]
36    #[serde(skip_serializing_if = "Option::is_none")]
37    pub account_link_status: Option<String>,
38    #[serde(rename = "SourceAccountId")]
39    #[serde(default)]
40    #[serde(skip_serializing_if = "Option::is_none")]
41    pub source_account_id: Option<String>,
42    #[serde(rename = "TargetAccountId")]
43    #[serde(default)]
44    #[serde(skip_serializing_if = "Option::is_none")]
45    pub target_account_id: Option<String>,
46}
47
48#[derive(Debug, Clone, Default, Deserialize, Serialize)]
49pub struct AssociateConnectionAliasRequest {
50    #[serde(rename = "AliasId")]
51    #[serde(default)]
52    pub alias_id: String,
53    #[serde(rename = "ResourceId")]
54    #[serde(default)]
55    pub resource_id: String,
56}
57
58#[derive(Debug, Clone, Default, Deserialize, Serialize)]
59pub struct AssociateConnectionAliasResult {
60    #[serde(rename = "ConnectionIdentifier")]
61    #[serde(default)]
62    #[serde(skip_serializing_if = "Option::is_none")]
63    pub connection_identifier: Option<String>,
64}
65
66#[derive(Debug, Clone, Default, Deserialize, Serialize)]
67pub struct AssociateIpGroupsRequest {
68    #[serde(rename = "DirectoryId")]
69    #[serde(default)]
70    pub directory_id: String,
71    #[serde(rename = "GroupIds")]
72    #[serde(default)]
73    pub group_ids: Vec<String>,
74}
75
76#[derive(Debug, Clone, Default, Deserialize, Serialize)]
77pub struct AssociateIpGroupsResult {}
78
79#[derive(Debug, Clone, Default, Deserialize, Serialize)]
80pub struct AssociateWorkspaceApplicationRequest {
81    #[serde(rename = "ApplicationId")]
82    #[serde(default)]
83    pub application_id: String,
84    #[serde(rename = "WorkspaceId")]
85    #[serde(default)]
86    pub workspace_id: String,
87}
88
89#[derive(Debug, Clone, Default, Deserialize, Serialize)]
90pub struct AssociateWorkspaceApplicationResult {
91    #[serde(rename = "Association")]
92    #[serde(default)]
93    #[serde(skip_serializing_if = "Option::is_none")]
94    pub association: Option<WorkspaceResourceAssociation>,
95}
96
97#[derive(Debug, Clone, Default, Deserialize, Serialize)]
98pub struct WorkspaceResourceAssociation {
99    #[serde(rename = "AssociatedResourceId")]
100    #[serde(default)]
101    #[serde(skip_serializing_if = "Option::is_none")]
102    pub associated_resource_id: Option<String>,
103    #[serde(rename = "AssociatedResourceType")]
104    #[serde(default)]
105    #[serde(skip_serializing_if = "Option::is_none")]
106    pub associated_resource_type: Option<String>,
107    #[serde(rename = "Created")]
108    #[serde(default)]
109    #[serde(skip_serializing_if = "Option::is_none")]
110    pub created: Option<f64>,
111    #[serde(rename = "LastUpdatedTime")]
112    #[serde(default)]
113    #[serde(skip_serializing_if = "Option::is_none")]
114    pub last_updated_time: Option<f64>,
115    #[serde(rename = "State")]
116    #[serde(default)]
117    #[serde(skip_serializing_if = "Option::is_none")]
118    pub state: Option<String>,
119    #[serde(rename = "StateReason")]
120    #[serde(default)]
121    #[serde(skip_serializing_if = "Option::is_none")]
122    pub state_reason: Option<AssociationStateReason>,
123    #[serde(rename = "WorkspaceId")]
124    #[serde(default)]
125    #[serde(skip_serializing_if = "Option::is_none")]
126    pub workspace_id: Option<String>,
127}
128
129#[derive(Debug, Clone, Default, Deserialize, Serialize)]
130pub struct AssociationStateReason {
131    #[serde(rename = "ErrorCode")]
132    #[serde(default)]
133    #[serde(skip_serializing_if = "Option::is_none")]
134    pub error_code: Option<String>,
135    #[serde(rename = "ErrorMessage")]
136    #[serde(default)]
137    #[serde(skip_serializing_if = "Option::is_none")]
138    pub error_message: Option<String>,
139}
140
141#[derive(Debug, Clone, Default, Deserialize, Serialize)]
142pub struct AuthorizeIpRulesRequest {
143    #[serde(rename = "GroupId")]
144    #[serde(default)]
145    pub group_id: String,
146    #[serde(rename = "UserRules")]
147    #[serde(default)]
148    pub user_rules: Vec<IpRuleItem>,
149}
150
151#[derive(Debug, Clone, Default, Deserialize, Serialize)]
152pub struct IpRuleItem {
153    #[serde(rename = "ipRule")]
154    #[serde(default)]
155    #[serde(skip_serializing_if = "Option::is_none")]
156    pub ip_rule: Option<String>,
157    #[serde(rename = "ruleDesc")]
158    #[serde(default)]
159    #[serde(skip_serializing_if = "Option::is_none")]
160    pub rule_desc: Option<String>,
161}
162
163#[derive(Debug, Clone, Default, Deserialize, Serialize)]
164pub struct AuthorizeIpRulesResult {}
165
166#[derive(Debug, Clone, Default, Deserialize, Serialize)]
167pub struct CopyWorkspaceImageRequest {
168    #[serde(rename = "Description")]
169    #[serde(default)]
170    #[serde(skip_serializing_if = "Option::is_none")]
171    pub description: Option<String>,
172    #[serde(rename = "Name")]
173    #[serde(default)]
174    pub name: String,
175    #[serde(rename = "SourceImageId")]
176    #[serde(default)]
177    pub source_image_id: String,
178    #[serde(rename = "SourceRegion")]
179    #[serde(default)]
180    pub source_region: String,
181    #[serde(rename = "Tags")]
182    #[serde(default)]
183    #[serde(skip_serializing_if = "Option::is_none")]
184    pub tags: Option<Vec<Tag>>,
185}
186
187#[derive(Debug, Clone, Default, Deserialize, Serialize)]
188pub struct Tag {
189    #[serde(rename = "Key")]
190    #[serde(default)]
191    pub key: String,
192    #[serde(rename = "Value")]
193    #[serde(default)]
194    #[serde(skip_serializing_if = "Option::is_none")]
195    pub value: Option<String>,
196}
197
198#[derive(Debug, Clone, Default, Deserialize, Serialize)]
199pub struct CopyWorkspaceImageResult {
200    #[serde(rename = "ImageId")]
201    #[serde(default)]
202    #[serde(skip_serializing_if = "Option::is_none")]
203    pub image_id: Option<String>,
204}
205
206#[derive(Debug, Clone, Default, Deserialize, Serialize)]
207pub struct CreateAccountLinkInvitationRequest {
208    #[serde(rename = "ClientToken")]
209    #[serde(default)]
210    #[serde(skip_serializing_if = "Option::is_none")]
211    pub client_token: Option<String>,
212    #[serde(rename = "TargetAccountId")]
213    #[serde(default)]
214    pub target_account_id: String,
215}
216
217#[derive(Debug, Clone, Default, Deserialize, Serialize)]
218pub struct CreateAccountLinkInvitationResult {
219    #[serde(rename = "AccountLink")]
220    #[serde(default)]
221    #[serde(skip_serializing_if = "Option::is_none")]
222    pub account_link: Option<AccountLink>,
223}
224
225#[derive(Debug, Clone, Default, Deserialize, Serialize)]
226pub struct CreateConnectClientAddInRequest {
227    #[serde(rename = "Name")]
228    #[serde(default)]
229    pub name: String,
230    #[serde(rename = "ResourceId")]
231    #[serde(default)]
232    pub resource_id: String,
233    #[serde(rename = "URL")]
234    #[serde(default)]
235    pub u_r_l: String,
236}
237
238#[derive(Debug, Clone, Default, Deserialize, Serialize)]
239pub struct CreateConnectClientAddInResult {
240    #[serde(rename = "AddInId")]
241    #[serde(default)]
242    #[serde(skip_serializing_if = "Option::is_none")]
243    pub add_in_id: Option<String>,
244}
245
246#[derive(Debug, Clone, Default, Deserialize, Serialize)]
247pub struct CreateConnectionAliasRequest {
248    #[serde(rename = "ConnectionString")]
249    #[serde(default)]
250    pub connection_string: String,
251    #[serde(rename = "Tags")]
252    #[serde(default)]
253    #[serde(skip_serializing_if = "Option::is_none")]
254    pub tags: Option<Vec<Tag>>,
255}
256
257#[derive(Debug, Clone, Default, Deserialize, Serialize)]
258pub struct CreateConnectionAliasResult {
259    #[serde(rename = "AliasId")]
260    #[serde(default)]
261    #[serde(skip_serializing_if = "Option::is_none")]
262    pub alias_id: Option<String>,
263}
264
265#[derive(Debug, Clone, Default, Deserialize, Serialize)]
266pub struct CreateIpGroupRequest {
267    #[serde(rename = "GroupDesc")]
268    #[serde(default)]
269    #[serde(skip_serializing_if = "Option::is_none")]
270    pub group_desc: Option<String>,
271    #[serde(rename = "GroupName")]
272    #[serde(default)]
273    pub group_name: String,
274    #[serde(rename = "Tags")]
275    #[serde(default)]
276    #[serde(skip_serializing_if = "Option::is_none")]
277    pub tags: Option<Vec<Tag>>,
278    #[serde(rename = "UserRules")]
279    #[serde(default)]
280    #[serde(skip_serializing_if = "Option::is_none")]
281    pub user_rules: Option<Vec<IpRuleItem>>,
282}
283
284#[derive(Debug, Clone, Default, Deserialize, Serialize)]
285pub struct CreateIpGroupResult {
286    #[serde(rename = "GroupId")]
287    #[serde(default)]
288    #[serde(skip_serializing_if = "Option::is_none")]
289    pub group_id: Option<String>,
290}
291
292#[derive(Debug, Clone, Default, Deserialize, Serialize)]
293pub struct CreateStandbyWorkspacesRequest {
294    #[serde(rename = "PrimaryRegion")]
295    #[serde(default)]
296    pub primary_region: String,
297    #[serde(rename = "StandbyWorkspaces")]
298    #[serde(default)]
299    pub standby_workspaces: Vec<StandbyWorkspace>,
300}
301
302#[derive(Debug, Clone, Default, Deserialize, Serialize)]
303pub struct StandbyWorkspace {
304    #[serde(rename = "DataReplication")]
305    #[serde(default)]
306    #[serde(skip_serializing_if = "Option::is_none")]
307    pub data_replication: Option<String>,
308    #[serde(rename = "DirectoryId")]
309    #[serde(default)]
310    pub directory_id: String,
311    #[serde(rename = "PrimaryWorkspaceId")]
312    #[serde(default)]
313    pub primary_workspace_id: String,
314    #[serde(rename = "Tags")]
315    #[serde(default)]
316    #[serde(skip_serializing_if = "Option::is_none")]
317    pub tags: Option<Vec<Tag>>,
318    #[serde(rename = "VolumeEncryptionKey")]
319    #[serde(default)]
320    #[serde(skip_serializing_if = "Option::is_none")]
321    pub volume_encryption_key: Option<String>,
322}
323
324#[derive(Debug, Clone, Default, Deserialize, Serialize)]
325pub struct CreateStandbyWorkspacesResult {
326    #[serde(rename = "FailedStandbyRequests")]
327    #[serde(default)]
328    #[serde(skip_serializing_if = "Option::is_none")]
329    pub failed_standby_requests: Option<Vec<FailedCreateStandbyWorkspacesRequest>>,
330    #[serde(rename = "PendingStandbyRequests")]
331    #[serde(default)]
332    #[serde(skip_serializing_if = "Option::is_none")]
333    pub pending_standby_requests: Option<Vec<PendingCreateStandbyWorkspacesRequest>>,
334}
335
336#[derive(Debug, Clone, Default, Deserialize, Serialize)]
337pub struct FailedCreateStandbyWorkspacesRequest {
338    #[serde(rename = "ErrorCode")]
339    #[serde(default)]
340    #[serde(skip_serializing_if = "Option::is_none")]
341    pub error_code: Option<String>,
342    #[serde(rename = "ErrorMessage")]
343    #[serde(default)]
344    #[serde(skip_serializing_if = "Option::is_none")]
345    pub error_message: Option<String>,
346    #[serde(rename = "StandbyWorkspaceRequest")]
347    #[serde(default)]
348    #[serde(skip_serializing_if = "Option::is_none")]
349    pub standby_workspace_request: Option<StandbyWorkspace>,
350}
351
352#[derive(Debug, Clone, Default, Deserialize, Serialize)]
353pub struct PendingCreateStandbyWorkspacesRequest {
354    #[serde(rename = "DirectoryId")]
355    #[serde(default)]
356    #[serde(skip_serializing_if = "Option::is_none")]
357    pub directory_id: Option<String>,
358    #[serde(rename = "State")]
359    #[serde(default)]
360    #[serde(skip_serializing_if = "Option::is_none")]
361    pub state: Option<String>,
362    #[serde(rename = "UserName")]
363    #[serde(default)]
364    #[serde(skip_serializing_if = "Option::is_none")]
365    pub user_name: Option<String>,
366    #[serde(rename = "WorkspaceId")]
367    #[serde(default)]
368    #[serde(skip_serializing_if = "Option::is_none")]
369    pub workspace_id: Option<String>,
370}
371
372#[derive(Debug, Clone, Default, Deserialize, Serialize)]
373pub struct CreateTagsRequest {
374    #[serde(rename = "ResourceId")]
375    #[serde(default)]
376    pub resource_id: String,
377    #[serde(rename = "Tags")]
378    #[serde(default)]
379    pub tags: Vec<Tag>,
380}
381
382#[derive(Debug, Clone, Default, Deserialize, Serialize)]
383pub struct CreateTagsResult {}
384
385#[derive(Debug, Clone, Default, Deserialize, Serialize)]
386pub struct CreateUpdatedWorkspaceImageRequest {
387    #[serde(rename = "Description")]
388    #[serde(default)]
389    pub description: String,
390    #[serde(rename = "Name")]
391    #[serde(default)]
392    pub name: String,
393    #[serde(rename = "SourceImageId")]
394    #[serde(default)]
395    pub source_image_id: String,
396    #[serde(rename = "Tags")]
397    #[serde(default)]
398    #[serde(skip_serializing_if = "Option::is_none")]
399    pub tags: Option<Vec<Tag>>,
400}
401
402#[derive(Debug, Clone, Default, Deserialize, Serialize)]
403pub struct CreateUpdatedWorkspaceImageResult {
404    #[serde(rename = "ImageId")]
405    #[serde(default)]
406    #[serde(skip_serializing_if = "Option::is_none")]
407    pub image_id: Option<String>,
408}
409
410#[derive(Debug, Clone, Default, Deserialize, Serialize)]
411pub struct CreateWorkspaceBundleRequest {
412    #[serde(rename = "BundleDescription")]
413    #[serde(default)]
414    pub bundle_description: String,
415    #[serde(rename = "BundleName")]
416    #[serde(default)]
417    pub bundle_name: String,
418    #[serde(rename = "ComputeType")]
419    #[serde(default)]
420    pub compute_type: ComputeType,
421    #[serde(rename = "ImageId")]
422    #[serde(default)]
423    pub image_id: String,
424    #[serde(rename = "RootStorage")]
425    #[serde(default)]
426    #[serde(skip_serializing_if = "Option::is_none")]
427    pub root_storage: Option<RootStorage>,
428    #[serde(rename = "Tags")]
429    #[serde(default)]
430    #[serde(skip_serializing_if = "Option::is_none")]
431    pub tags: Option<Vec<Tag>>,
432    #[serde(rename = "UserStorage")]
433    #[serde(default)]
434    pub user_storage: UserStorage,
435}
436
437#[derive(Debug, Clone, Default, Deserialize, Serialize)]
438pub struct ComputeType {
439    #[serde(rename = "Name")]
440    #[serde(default)]
441    #[serde(skip_serializing_if = "Option::is_none")]
442    pub name: Option<String>,
443}
444
445#[derive(Debug, Clone, Default, Deserialize, Serialize)]
446pub struct RootStorage {
447    #[serde(rename = "Capacity")]
448    #[serde(default)]
449    pub capacity: String,
450}
451
452#[derive(Debug, Clone, Default, Deserialize, Serialize)]
453pub struct UserStorage {
454    #[serde(rename = "Capacity")]
455    #[serde(default)]
456    pub capacity: String,
457}
458
459#[derive(Debug, Clone, Default, Deserialize, Serialize)]
460pub struct CreateWorkspaceBundleResult {
461    #[serde(rename = "WorkspaceBundle")]
462    #[serde(default)]
463    #[serde(skip_serializing_if = "Option::is_none")]
464    pub workspace_bundle: Option<WorkspaceBundle>,
465}
466
467#[derive(Debug, Clone, Default, Deserialize, Serialize)]
468pub struct WorkspaceBundle {
469    #[serde(rename = "BundleId")]
470    #[serde(default)]
471    #[serde(skip_serializing_if = "Option::is_none")]
472    pub bundle_id: Option<String>,
473    #[serde(rename = "BundleType")]
474    #[serde(default)]
475    #[serde(skip_serializing_if = "Option::is_none")]
476    pub bundle_type: Option<String>,
477    #[serde(rename = "ComputeType")]
478    #[serde(default)]
479    #[serde(skip_serializing_if = "Option::is_none")]
480    pub compute_type: Option<ComputeType>,
481    #[serde(rename = "CreationTime")]
482    #[serde(default)]
483    #[serde(skip_serializing_if = "Option::is_none")]
484    pub creation_time: Option<f64>,
485    #[serde(rename = "Description")]
486    #[serde(default)]
487    #[serde(skip_serializing_if = "Option::is_none")]
488    pub description: Option<String>,
489    #[serde(rename = "ImageId")]
490    #[serde(default)]
491    #[serde(skip_serializing_if = "Option::is_none")]
492    pub image_id: Option<String>,
493    #[serde(rename = "LastUpdatedTime")]
494    #[serde(default)]
495    #[serde(skip_serializing_if = "Option::is_none")]
496    pub last_updated_time: Option<f64>,
497    #[serde(rename = "Name")]
498    #[serde(default)]
499    #[serde(skip_serializing_if = "Option::is_none")]
500    pub name: Option<String>,
501    #[serde(rename = "Owner")]
502    #[serde(default)]
503    #[serde(skip_serializing_if = "Option::is_none")]
504    pub owner: Option<String>,
505    #[serde(rename = "RootStorage")]
506    #[serde(default)]
507    #[serde(skip_serializing_if = "Option::is_none")]
508    pub root_storage: Option<RootStorage>,
509    #[serde(rename = "State")]
510    #[serde(default)]
511    #[serde(skip_serializing_if = "Option::is_none")]
512    pub state: Option<String>,
513    #[serde(rename = "UserStorage")]
514    #[serde(default)]
515    #[serde(skip_serializing_if = "Option::is_none")]
516    pub user_storage: Option<UserStorage>,
517}
518
519#[derive(Debug, Clone, Default, Deserialize, Serialize)]
520pub struct CreateWorkspaceImageRequest {
521    #[serde(rename = "Description")]
522    #[serde(default)]
523    pub description: String,
524    #[serde(rename = "Name")]
525    #[serde(default)]
526    pub name: String,
527    #[serde(rename = "Tags")]
528    #[serde(default)]
529    #[serde(skip_serializing_if = "Option::is_none")]
530    pub tags: Option<Vec<Tag>>,
531    #[serde(rename = "WorkspaceId")]
532    #[serde(default)]
533    pub workspace_id: String,
534}
535
536#[derive(Debug, Clone, Default, Deserialize, Serialize)]
537pub struct CreateWorkspaceImageResult {
538    #[serde(rename = "Created")]
539    #[serde(default)]
540    #[serde(skip_serializing_if = "Option::is_none")]
541    pub created: Option<f64>,
542    #[serde(rename = "Description")]
543    #[serde(default)]
544    #[serde(skip_serializing_if = "Option::is_none")]
545    pub description: Option<String>,
546    #[serde(rename = "ImageId")]
547    #[serde(default)]
548    #[serde(skip_serializing_if = "Option::is_none")]
549    pub image_id: Option<String>,
550    #[serde(rename = "Name")]
551    #[serde(default)]
552    #[serde(skip_serializing_if = "Option::is_none")]
553    pub name: Option<String>,
554    #[serde(rename = "OperatingSystem")]
555    #[serde(default)]
556    #[serde(skip_serializing_if = "Option::is_none")]
557    pub operating_system: Option<OperatingSystem>,
558    #[serde(rename = "OwnerAccountId")]
559    #[serde(default)]
560    #[serde(skip_serializing_if = "Option::is_none")]
561    pub owner_account_id: Option<String>,
562    #[serde(rename = "RequiredTenancy")]
563    #[serde(default)]
564    #[serde(skip_serializing_if = "Option::is_none")]
565    pub required_tenancy: Option<String>,
566    #[serde(rename = "State")]
567    #[serde(default)]
568    #[serde(skip_serializing_if = "Option::is_none")]
569    pub state: Option<String>,
570}
571
572#[derive(Debug, Clone, Default, Deserialize, Serialize)]
573pub struct OperatingSystem {
574    #[serde(rename = "Type")]
575    #[serde(default)]
576    #[serde(skip_serializing_if = "Option::is_none")]
577    pub r#type: Option<String>,
578}
579
580#[derive(Debug, Clone, Default, Deserialize, Serialize)]
581pub struct CreateWorkspacesPoolRequest {
582    #[serde(rename = "ApplicationSettings")]
583    #[serde(default)]
584    #[serde(skip_serializing_if = "Option::is_none")]
585    pub application_settings: Option<ApplicationSettingsRequest>,
586    #[serde(rename = "BundleId")]
587    #[serde(default)]
588    pub bundle_id: String,
589    #[serde(rename = "Capacity")]
590    #[serde(default)]
591    pub capacity: Capacity,
592    #[serde(rename = "Description")]
593    #[serde(default)]
594    pub description: String,
595    #[serde(rename = "DirectoryId")]
596    #[serde(default)]
597    pub directory_id: String,
598    #[serde(rename = "PoolName")]
599    #[serde(default)]
600    pub pool_name: String,
601    #[serde(rename = "RunningMode")]
602    #[serde(default)]
603    #[serde(skip_serializing_if = "Option::is_none")]
604    pub running_mode: Option<String>,
605    #[serde(rename = "Tags")]
606    #[serde(default)]
607    #[serde(skip_serializing_if = "Option::is_none")]
608    pub tags: Option<Vec<Tag>>,
609    #[serde(rename = "TimeoutSettings")]
610    #[serde(default)]
611    #[serde(skip_serializing_if = "Option::is_none")]
612    pub timeout_settings: Option<TimeoutSettings>,
613}
614
615#[derive(Debug, Clone, Default, Deserialize, Serialize)]
616pub struct ApplicationSettingsRequest {
617    #[serde(rename = "SettingsGroup")]
618    #[serde(default)]
619    #[serde(skip_serializing_if = "Option::is_none")]
620    pub settings_group: Option<String>,
621    #[serde(rename = "Status")]
622    #[serde(default)]
623    pub status: String,
624}
625
626#[derive(Debug, Clone, Default, Deserialize, Serialize)]
627pub struct Capacity {
628    #[serde(rename = "DesiredUserSessions")]
629    #[serde(default)]
630    pub desired_user_sessions: i32,
631}
632
633#[derive(Debug, Clone, Default, Deserialize, Serialize)]
634pub struct TimeoutSettings {
635    #[serde(rename = "DisconnectTimeoutInSeconds")]
636    #[serde(default)]
637    #[serde(skip_serializing_if = "Option::is_none")]
638    pub disconnect_timeout_in_seconds: Option<i32>,
639    #[serde(rename = "IdleDisconnectTimeoutInSeconds")]
640    #[serde(default)]
641    #[serde(skip_serializing_if = "Option::is_none")]
642    pub idle_disconnect_timeout_in_seconds: Option<i32>,
643    #[serde(rename = "MaxUserDurationInSeconds")]
644    #[serde(default)]
645    #[serde(skip_serializing_if = "Option::is_none")]
646    pub max_user_duration_in_seconds: Option<i32>,
647}
648
649#[derive(Debug, Clone, Default, Deserialize, Serialize)]
650pub struct CreateWorkspacesPoolResult {
651    #[serde(rename = "WorkspacesPool")]
652    #[serde(default)]
653    #[serde(skip_serializing_if = "Option::is_none")]
654    pub workspaces_pool: Option<WorkspacesPool>,
655}
656
657#[derive(Debug, Clone, Default, Deserialize, Serialize)]
658pub struct WorkspacesPool {
659    #[serde(rename = "ApplicationSettings")]
660    #[serde(default)]
661    #[serde(skip_serializing_if = "Option::is_none")]
662    pub application_settings: Option<ApplicationSettingsResponse>,
663    #[serde(rename = "BundleId")]
664    #[serde(default)]
665    #[serde(skip_serializing_if = "Option::is_none")]
666    pub bundle_id: Option<String>,
667    #[serde(rename = "CapacityStatus")]
668    #[serde(default)]
669    #[serde(skip_serializing_if = "Option::is_none")]
670    pub capacity_status: Option<CapacityStatus>,
671    #[serde(rename = "CreatedAt")]
672    #[serde(default)]
673    #[serde(skip_serializing_if = "Option::is_none")]
674    pub created_at: Option<f64>,
675    #[serde(rename = "Description")]
676    #[serde(default)]
677    #[serde(skip_serializing_if = "Option::is_none")]
678    pub description: Option<String>,
679    #[serde(rename = "DirectoryId")]
680    #[serde(default)]
681    #[serde(skip_serializing_if = "Option::is_none")]
682    pub directory_id: Option<String>,
683    #[serde(rename = "Errors")]
684    #[serde(default)]
685    #[serde(skip_serializing_if = "Option::is_none")]
686    pub errors: Option<Vec<WorkspacesPoolError>>,
687    #[serde(rename = "PoolArn")]
688    #[serde(default)]
689    #[serde(skip_serializing_if = "Option::is_none")]
690    pub pool_arn: Option<String>,
691    #[serde(rename = "PoolId")]
692    #[serde(default)]
693    #[serde(skip_serializing_if = "Option::is_none")]
694    pub pool_id: Option<String>,
695    #[serde(rename = "PoolName")]
696    #[serde(default)]
697    #[serde(skip_serializing_if = "Option::is_none")]
698    pub pool_name: Option<String>,
699    #[serde(rename = "RunningMode")]
700    #[serde(default)]
701    #[serde(skip_serializing_if = "Option::is_none")]
702    pub running_mode: Option<String>,
703    #[serde(rename = "State")]
704    #[serde(default)]
705    #[serde(skip_serializing_if = "Option::is_none")]
706    pub state: Option<String>,
707    #[serde(rename = "TimeoutSettings")]
708    #[serde(default)]
709    #[serde(skip_serializing_if = "Option::is_none")]
710    pub timeout_settings: Option<TimeoutSettings>,
711}
712
713#[derive(Debug, Clone, Default, Deserialize, Serialize)]
714pub struct ApplicationSettingsResponse {
715    #[serde(rename = "S3BucketName")]
716    #[serde(default)]
717    #[serde(skip_serializing_if = "Option::is_none")]
718    pub s3_bucket_name: Option<String>,
719    #[serde(rename = "SettingsGroup")]
720    #[serde(default)]
721    #[serde(skip_serializing_if = "Option::is_none")]
722    pub settings_group: Option<String>,
723    #[serde(rename = "Status")]
724    #[serde(default)]
725    #[serde(skip_serializing_if = "Option::is_none")]
726    pub status: Option<String>,
727}
728
729#[derive(Debug, Clone, Default, Deserialize, Serialize)]
730pub struct CapacityStatus {
731    #[serde(rename = "ActiveUserSessions")]
732    #[serde(default)]
733    #[serde(skip_serializing_if = "Option::is_none")]
734    pub active_user_sessions: Option<i32>,
735    #[serde(rename = "ActualUserSessions")]
736    #[serde(default)]
737    #[serde(skip_serializing_if = "Option::is_none")]
738    pub actual_user_sessions: Option<i32>,
739    #[serde(rename = "AvailableUserSessions")]
740    #[serde(default)]
741    #[serde(skip_serializing_if = "Option::is_none")]
742    pub available_user_sessions: Option<i32>,
743    #[serde(rename = "DesiredUserSessions")]
744    #[serde(default)]
745    #[serde(skip_serializing_if = "Option::is_none")]
746    pub desired_user_sessions: Option<i32>,
747}
748
749#[derive(Debug, Clone, Default, Deserialize, Serialize)]
750pub struct WorkspacesPoolError {
751    #[serde(rename = "ErrorCode")]
752    #[serde(default)]
753    #[serde(skip_serializing_if = "Option::is_none")]
754    pub error_code: Option<String>,
755    #[serde(rename = "ErrorMessage")]
756    #[serde(default)]
757    #[serde(skip_serializing_if = "Option::is_none")]
758    pub error_message: Option<String>,
759}
760
761#[derive(Debug, Clone, Default, Deserialize, Serialize)]
762pub struct CreateWorkspacesRequest {
763    #[serde(rename = "Workspaces")]
764    #[serde(default)]
765    pub workspaces: Vec<WorkspaceRequest>,
766}
767
768#[derive(Debug, Clone, Default, Deserialize, Serialize)]
769pub struct WorkspaceRequest {
770    #[serde(rename = "BundleId")]
771    #[serde(default)]
772    pub bundle_id: String,
773    #[serde(rename = "DirectoryId")]
774    #[serde(default)]
775    pub directory_id: String,
776    #[serde(rename = "Ipv6Address")]
777    #[serde(default)]
778    #[serde(skip_serializing_if = "Option::is_none")]
779    pub ipv6_address: Option<String>,
780    #[serde(rename = "RootVolumeEncryptionEnabled")]
781    #[serde(default)]
782    #[serde(skip_serializing_if = "Option::is_none")]
783    pub root_volume_encryption_enabled: Option<bool>,
784    #[serde(rename = "Tags")]
785    #[serde(default)]
786    #[serde(skip_serializing_if = "Option::is_none")]
787    pub tags: Option<Vec<Tag>>,
788    #[serde(rename = "UserName")]
789    #[serde(default)]
790    pub user_name: String,
791    #[serde(rename = "UserVolumeEncryptionEnabled")]
792    #[serde(default)]
793    #[serde(skip_serializing_if = "Option::is_none")]
794    pub user_volume_encryption_enabled: Option<bool>,
795    #[serde(rename = "VolumeEncryptionKey")]
796    #[serde(default)]
797    #[serde(skip_serializing_if = "Option::is_none")]
798    pub volume_encryption_key: Option<String>,
799    #[serde(rename = "WorkspaceName")]
800    #[serde(default)]
801    #[serde(skip_serializing_if = "Option::is_none")]
802    pub workspace_name: Option<String>,
803    #[serde(rename = "WorkspaceProperties")]
804    #[serde(default)]
805    #[serde(skip_serializing_if = "Option::is_none")]
806    pub workspace_properties: Option<WorkspaceProperties>,
807}
808
809#[derive(Debug, Clone, Default, Deserialize, Serialize)]
810pub struct WorkspaceProperties {
811    #[serde(rename = "ComputeTypeName")]
812    #[serde(default)]
813    #[serde(skip_serializing_if = "Option::is_none")]
814    pub compute_type_name: Option<String>,
815    #[serde(rename = "GlobalAccelerator")]
816    #[serde(default)]
817    #[serde(skip_serializing_if = "Option::is_none")]
818    pub global_accelerator: Option<GlobalAcceleratorForWorkSpace>,
819    #[serde(rename = "OperatingSystemName")]
820    #[serde(default)]
821    #[serde(skip_serializing_if = "Option::is_none")]
822    pub operating_system_name: Option<String>,
823    #[serde(rename = "Protocols")]
824    #[serde(default)]
825    #[serde(skip_serializing_if = "Option::is_none")]
826    pub protocols: Option<Vec<String>>,
827    #[serde(rename = "RootVolumeSizeGib")]
828    #[serde(default)]
829    #[serde(skip_serializing_if = "Option::is_none")]
830    pub root_volume_size_gib: Option<i32>,
831    #[serde(rename = "RunningMode")]
832    #[serde(default)]
833    #[serde(skip_serializing_if = "Option::is_none")]
834    pub running_mode: Option<String>,
835    #[serde(rename = "RunningModeAutoStopTimeoutInMinutes")]
836    #[serde(default)]
837    #[serde(skip_serializing_if = "Option::is_none")]
838    pub running_mode_auto_stop_timeout_in_minutes: Option<i32>,
839    #[serde(rename = "UserVolumeSizeGib")]
840    #[serde(default)]
841    #[serde(skip_serializing_if = "Option::is_none")]
842    pub user_volume_size_gib: Option<i32>,
843}
844
845#[derive(Debug, Clone, Default, Deserialize, Serialize)]
846pub struct GlobalAcceleratorForWorkSpace {
847    #[serde(rename = "Mode")]
848    #[serde(default)]
849    pub mode: String,
850    #[serde(rename = "PreferredProtocol")]
851    #[serde(default)]
852    #[serde(skip_serializing_if = "Option::is_none")]
853    pub preferred_protocol: Option<String>,
854}
855
856#[derive(Debug, Clone, Default, Deserialize, Serialize)]
857pub struct CreateWorkspacesResult {
858    #[serde(rename = "FailedRequests")]
859    #[serde(default)]
860    #[serde(skip_serializing_if = "Option::is_none")]
861    pub failed_requests: Option<Vec<FailedCreateWorkspaceRequest>>,
862    #[serde(rename = "PendingRequests")]
863    #[serde(default)]
864    #[serde(skip_serializing_if = "Option::is_none")]
865    pub pending_requests: Option<Vec<Workspace>>,
866}
867
868#[derive(Debug, Clone, Default, Deserialize, Serialize)]
869pub struct FailedCreateWorkspaceRequest {
870    #[serde(rename = "ErrorCode")]
871    #[serde(default)]
872    #[serde(skip_serializing_if = "Option::is_none")]
873    pub error_code: Option<String>,
874    #[serde(rename = "ErrorMessage")]
875    #[serde(default)]
876    #[serde(skip_serializing_if = "Option::is_none")]
877    pub error_message: Option<String>,
878    #[serde(rename = "WorkspaceRequest")]
879    #[serde(default)]
880    #[serde(skip_serializing_if = "Option::is_none")]
881    pub workspace_request: Option<WorkspaceRequest>,
882}
883
884#[derive(Debug, Clone, Default, Deserialize, Serialize)]
885pub struct Workspace {
886    #[serde(rename = "BundleId")]
887    #[serde(default)]
888    #[serde(skip_serializing_if = "Option::is_none")]
889    pub bundle_id: Option<String>,
890    #[serde(rename = "ComputerName")]
891    #[serde(default)]
892    #[serde(skip_serializing_if = "Option::is_none")]
893    pub computer_name: Option<String>,
894    #[serde(rename = "DataReplicationSettings")]
895    #[serde(default)]
896    #[serde(skip_serializing_if = "Option::is_none")]
897    pub data_replication_settings: Option<DataReplicationSettings>,
898    #[serde(rename = "DirectoryId")]
899    #[serde(default)]
900    #[serde(skip_serializing_if = "Option::is_none")]
901    pub directory_id: Option<String>,
902    #[serde(rename = "ErrorCode")]
903    #[serde(default)]
904    #[serde(skip_serializing_if = "Option::is_none")]
905    pub error_code: Option<String>,
906    #[serde(rename = "ErrorMessage")]
907    #[serde(default)]
908    #[serde(skip_serializing_if = "Option::is_none")]
909    pub error_message: Option<String>,
910    #[serde(rename = "IpAddress")]
911    #[serde(default)]
912    #[serde(skip_serializing_if = "Option::is_none")]
913    pub ip_address: Option<String>,
914    #[serde(rename = "Ipv6Address")]
915    #[serde(default)]
916    #[serde(skip_serializing_if = "Option::is_none")]
917    pub ipv6_address: Option<String>,
918    #[serde(rename = "ModificationStates")]
919    #[serde(default)]
920    #[serde(skip_serializing_if = "Option::is_none")]
921    pub modification_states: Option<Vec<ModificationState>>,
922    #[serde(rename = "RelatedWorkspaces")]
923    #[serde(default)]
924    #[serde(skip_serializing_if = "Option::is_none")]
925    pub related_workspaces: Option<Vec<RelatedWorkspaceProperties>>,
926    #[serde(rename = "RootVolumeEncryptionEnabled")]
927    #[serde(default)]
928    #[serde(skip_serializing_if = "Option::is_none")]
929    pub root_volume_encryption_enabled: Option<bool>,
930    #[serde(rename = "StandbyWorkspacesProperties")]
931    #[serde(default)]
932    #[serde(skip_serializing_if = "Option::is_none")]
933    pub standby_workspaces_properties: Option<Vec<StandbyWorkspacesProperties>>,
934    #[serde(rename = "State")]
935    #[serde(default)]
936    #[serde(skip_serializing_if = "Option::is_none")]
937    pub state: Option<String>,
938    #[serde(rename = "SubnetId")]
939    #[serde(default)]
940    #[serde(skip_serializing_if = "Option::is_none")]
941    pub subnet_id: Option<String>,
942    #[serde(rename = "UserName")]
943    #[serde(default)]
944    #[serde(skip_serializing_if = "Option::is_none")]
945    pub user_name: Option<String>,
946    #[serde(rename = "UserVolumeEncryptionEnabled")]
947    #[serde(default)]
948    #[serde(skip_serializing_if = "Option::is_none")]
949    pub user_volume_encryption_enabled: Option<bool>,
950    #[serde(rename = "VolumeEncryptionKey")]
951    #[serde(default)]
952    #[serde(skip_serializing_if = "Option::is_none")]
953    pub volume_encryption_key: Option<String>,
954    #[serde(rename = "WorkspaceId")]
955    #[serde(default)]
956    #[serde(skip_serializing_if = "Option::is_none")]
957    pub workspace_id: Option<String>,
958    #[serde(rename = "WorkspaceName")]
959    #[serde(default)]
960    #[serde(skip_serializing_if = "Option::is_none")]
961    pub workspace_name: Option<String>,
962    #[serde(rename = "WorkspaceProperties")]
963    #[serde(default)]
964    #[serde(skip_serializing_if = "Option::is_none")]
965    pub workspace_properties: Option<WorkspaceProperties>,
966}
967
968#[derive(Debug, Clone, Default, Deserialize, Serialize)]
969pub struct DataReplicationSettings {
970    #[serde(rename = "DataReplication")]
971    #[serde(default)]
972    #[serde(skip_serializing_if = "Option::is_none")]
973    pub data_replication: Option<String>,
974    #[serde(rename = "RecoverySnapshotTime")]
975    #[serde(default)]
976    #[serde(skip_serializing_if = "Option::is_none")]
977    pub recovery_snapshot_time: Option<f64>,
978}
979
980#[derive(Debug, Clone, Default, Deserialize, Serialize)]
981pub struct ModificationState {
982    #[serde(rename = "Resource")]
983    #[serde(default)]
984    #[serde(skip_serializing_if = "Option::is_none")]
985    pub resource: Option<String>,
986    #[serde(rename = "State")]
987    #[serde(default)]
988    #[serde(skip_serializing_if = "Option::is_none")]
989    pub state: Option<String>,
990}
991
992#[derive(Debug, Clone, Default, Deserialize, Serialize)]
993pub struct RelatedWorkspaceProperties {
994    #[serde(rename = "Region")]
995    #[serde(default)]
996    #[serde(skip_serializing_if = "Option::is_none")]
997    pub region: Option<String>,
998    #[serde(rename = "State")]
999    #[serde(default)]
1000    #[serde(skip_serializing_if = "Option::is_none")]
1001    pub state: Option<String>,
1002    #[serde(rename = "Type")]
1003    #[serde(default)]
1004    #[serde(skip_serializing_if = "Option::is_none")]
1005    pub r#type: Option<String>,
1006    #[serde(rename = "WorkspaceId")]
1007    #[serde(default)]
1008    #[serde(skip_serializing_if = "Option::is_none")]
1009    pub workspace_id: Option<String>,
1010}
1011
1012#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1013pub struct StandbyWorkspacesProperties {
1014    #[serde(rename = "DataReplication")]
1015    #[serde(default)]
1016    #[serde(skip_serializing_if = "Option::is_none")]
1017    pub data_replication: Option<String>,
1018    #[serde(rename = "RecoverySnapshotTime")]
1019    #[serde(default)]
1020    #[serde(skip_serializing_if = "Option::is_none")]
1021    pub recovery_snapshot_time: Option<f64>,
1022    #[serde(rename = "StandbyWorkspaceId")]
1023    #[serde(default)]
1024    #[serde(skip_serializing_if = "Option::is_none")]
1025    pub standby_workspace_id: Option<String>,
1026}
1027
1028#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1029pub struct DeleteAccountLinkInvitationRequest {
1030    #[serde(rename = "ClientToken")]
1031    #[serde(default)]
1032    #[serde(skip_serializing_if = "Option::is_none")]
1033    pub client_token: Option<String>,
1034    #[serde(rename = "LinkId")]
1035    #[serde(default)]
1036    pub link_id: String,
1037}
1038
1039#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1040pub struct DeleteAccountLinkInvitationResult {
1041    #[serde(rename = "AccountLink")]
1042    #[serde(default)]
1043    #[serde(skip_serializing_if = "Option::is_none")]
1044    pub account_link: Option<AccountLink>,
1045}
1046
1047#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1048pub struct DeleteClientBrandingRequest {
1049    #[serde(rename = "Platforms")]
1050    #[serde(default)]
1051    pub platforms: Vec<String>,
1052    #[serde(rename = "ResourceId")]
1053    #[serde(default)]
1054    pub resource_id: String,
1055}
1056
1057#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1058pub struct DeleteClientBrandingResult {}
1059
1060#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1061pub struct DeleteConnectClientAddInRequest {
1062    #[serde(rename = "AddInId")]
1063    #[serde(default)]
1064    pub add_in_id: String,
1065    #[serde(rename = "ResourceId")]
1066    #[serde(default)]
1067    pub resource_id: String,
1068}
1069
1070#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1071pub struct DeleteConnectClientAddInResult {}
1072
1073#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1074pub struct DeleteConnectionAliasRequest {
1075    #[serde(rename = "AliasId")]
1076    #[serde(default)]
1077    pub alias_id: String,
1078}
1079
1080#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1081pub struct DeleteConnectionAliasResult {}
1082
1083#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1084pub struct DeleteIpGroupRequest {
1085    #[serde(rename = "GroupId")]
1086    #[serde(default)]
1087    pub group_id: String,
1088}
1089
1090#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1091pub struct DeleteIpGroupResult {}
1092
1093#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1094pub struct DeleteTagsRequest {
1095    #[serde(rename = "ResourceId")]
1096    #[serde(default)]
1097    pub resource_id: String,
1098    #[serde(rename = "TagKeys")]
1099    #[serde(default)]
1100    pub tag_keys: Vec<String>,
1101}
1102
1103#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1104pub struct DeleteTagsResult {}
1105
1106#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1107pub struct DeleteWorkspaceBundleRequest {
1108    #[serde(rename = "BundleId")]
1109    #[serde(default)]
1110    #[serde(skip_serializing_if = "Option::is_none")]
1111    pub bundle_id: Option<String>,
1112}
1113
1114#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1115pub struct DeleteWorkspaceBundleResult {}
1116
1117#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1118pub struct DeleteWorkspaceImageRequest {
1119    #[serde(rename = "ImageId")]
1120    #[serde(default)]
1121    pub image_id: String,
1122}
1123
1124#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1125pub struct DeleteWorkspaceImageResult {}
1126
1127#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1128pub struct DeployWorkspaceApplicationsRequest {
1129    #[serde(rename = "Force")]
1130    #[serde(default)]
1131    #[serde(skip_serializing_if = "Option::is_none")]
1132    pub force: Option<bool>,
1133    #[serde(rename = "WorkspaceId")]
1134    #[serde(default)]
1135    pub workspace_id: String,
1136}
1137
1138#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1139pub struct DeployWorkspaceApplicationsResult {
1140    #[serde(rename = "Deployment")]
1141    #[serde(default)]
1142    #[serde(skip_serializing_if = "Option::is_none")]
1143    pub deployment: Option<WorkSpaceApplicationDeployment>,
1144}
1145
1146#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1147pub struct WorkSpaceApplicationDeployment {
1148    #[serde(rename = "Associations")]
1149    #[serde(default)]
1150    #[serde(skip_serializing_if = "Option::is_none")]
1151    pub associations: Option<Vec<WorkspaceResourceAssociation>>,
1152}
1153
1154#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1155pub struct DeregisterWorkspaceDirectoryRequest {
1156    #[serde(rename = "DirectoryId")]
1157    #[serde(default)]
1158    pub directory_id: String,
1159}
1160
1161#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1162pub struct DeregisterWorkspaceDirectoryResult {}
1163
1164#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1165pub struct DescribeAccountModificationsRequest {
1166    #[serde(rename = "NextToken")]
1167    #[serde(default)]
1168    #[serde(skip_serializing_if = "Option::is_none")]
1169    pub next_token: Option<String>,
1170}
1171
1172#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1173pub struct DescribeAccountModificationsResult {
1174    #[serde(rename = "AccountModifications")]
1175    #[serde(default)]
1176    #[serde(skip_serializing_if = "Option::is_none")]
1177    pub account_modifications: Option<Vec<AccountModification>>,
1178    #[serde(rename = "NextToken")]
1179    #[serde(default)]
1180    #[serde(skip_serializing_if = "Option::is_none")]
1181    pub next_token: Option<String>,
1182}
1183
1184#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1185pub struct AccountModification {
1186    #[serde(rename = "DedicatedTenancyManagementCidrRange")]
1187    #[serde(default)]
1188    #[serde(skip_serializing_if = "Option::is_none")]
1189    pub dedicated_tenancy_management_cidr_range: Option<String>,
1190    #[serde(rename = "DedicatedTenancySupport")]
1191    #[serde(default)]
1192    #[serde(skip_serializing_if = "Option::is_none")]
1193    pub dedicated_tenancy_support: Option<String>,
1194    #[serde(rename = "ErrorCode")]
1195    #[serde(default)]
1196    #[serde(skip_serializing_if = "Option::is_none")]
1197    pub error_code: Option<String>,
1198    #[serde(rename = "ErrorMessage")]
1199    #[serde(default)]
1200    #[serde(skip_serializing_if = "Option::is_none")]
1201    pub error_message: Option<String>,
1202    #[serde(rename = "ModificationState")]
1203    #[serde(default)]
1204    #[serde(skip_serializing_if = "Option::is_none")]
1205    pub modification_state: Option<String>,
1206    #[serde(rename = "StartTime")]
1207    #[serde(default)]
1208    #[serde(skip_serializing_if = "Option::is_none")]
1209    pub start_time: Option<f64>,
1210}
1211
1212#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1213pub struct DescribeAccountRequest {}
1214
1215#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1216pub struct DescribeAccountResult {
1217    #[serde(rename = "DedicatedTenancyAccountType")]
1218    #[serde(default)]
1219    #[serde(skip_serializing_if = "Option::is_none")]
1220    pub dedicated_tenancy_account_type: Option<String>,
1221    #[serde(rename = "DedicatedTenancyManagementCidrRange")]
1222    #[serde(default)]
1223    #[serde(skip_serializing_if = "Option::is_none")]
1224    pub dedicated_tenancy_management_cidr_range: Option<String>,
1225    #[serde(rename = "DedicatedTenancySupport")]
1226    #[serde(default)]
1227    #[serde(skip_serializing_if = "Option::is_none")]
1228    pub dedicated_tenancy_support: Option<String>,
1229    #[serde(rename = "Message")]
1230    #[serde(default)]
1231    #[serde(skip_serializing_if = "Option::is_none")]
1232    pub message: Option<String>,
1233}
1234
1235#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1236pub struct DescribeApplicationAssociationsRequest {
1237    #[serde(rename = "ApplicationId")]
1238    #[serde(default)]
1239    pub application_id: String,
1240    #[serde(rename = "AssociatedResourceTypes")]
1241    #[serde(default)]
1242    pub associated_resource_types: Vec<String>,
1243    #[serde(rename = "MaxResults")]
1244    #[serde(default)]
1245    #[serde(skip_serializing_if = "Option::is_none")]
1246    pub max_results: Option<i32>,
1247    #[serde(rename = "NextToken")]
1248    #[serde(default)]
1249    #[serde(skip_serializing_if = "Option::is_none")]
1250    pub next_token: Option<String>,
1251}
1252
1253#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1254pub struct DescribeApplicationAssociationsResult {
1255    #[serde(rename = "Associations")]
1256    #[serde(default)]
1257    #[serde(skip_serializing_if = "Option::is_none")]
1258    pub associations: Option<Vec<ApplicationResourceAssociation>>,
1259    #[serde(rename = "NextToken")]
1260    #[serde(default)]
1261    #[serde(skip_serializing_if = "Option::is_none")]
1262    pub next_token: Option<String>,
1263}
1264
1265#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1266pub struct ApplicationResourceAssociation {
1267    #[serde(rename = "ApplicationId")]
1268    #[serde(default)]
1269    #[serde(skip_serializing_if = "Option::is_none")]
1270    pub application_id: Option<String>,
1271    #[serde(rename = "AssociatedResourceId")]
1272    #[serde(default)]
1273    #[serde(skip_serializing_if = "Option::is_none")]
1274    pub associated_resource_id: Option<String>,
1275    #[serde(rename = "AssociatedResourceType")]
1276    #[serde(default)]
1277    #[serde(skip_serializing_if = "Option::is_none")]
1278    pub associated_resource_type: Option<String>,
1279    #[serde(rename = "Created")]
1280    #[serde(default)]
1281    #[serde(skip_serializing_if = "Option::is_none")]
1282    pub created: Option<f64>,
1283    #[serde(rename = "LastUpdatedTime")]
1284    #[serde(default)]
1285    #[serde(skip_serializing_if = "Option::is_none")]
1286    pub last_updated_time: Option<f64>,
1287    #[serde(rename = "State")]
1288    #[serde(default)]
1289    #[serde(skip_serializing_if = "Option::is_none")]
1290    pub state: Option<String>,
1291    #[serde(rename = "StateReason")]
1292    #[serde(default)]
1293    #[serde(skip_serializing_if = "Option::is_none")]
1294    pub state_reason: Option<AssociationStateReason>,
1295}
1296
1297#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1298pub struct DescribeApplicationsRequest {
1299    #[serde(rename = "ApplicationIds")]
1300    #[serde(default)]
1301    #[serde(skip_serializing_if = "Option::is_none")]
1302    pub application_ids: Option<Vec<String>>,
1303    #[serde(rename = "ComputeTypeNames")]
1304    #[serde(default)]
1305    #[serde(skip_serializing_if = "Option::is_none")]
1306    pub compute_type_names: Option<Vec<String>>,
1307    #[serde(rename = "LicenseType")]
1308    #[serde(default)]
1309    #[serde(skip_serializing_if = "Option::is_none")]
1310    pub license_type: Option<String>,
1311    #[serde(rename = "MaxResults")]
1312    #[serde(default)]
1313    #[serde(skip_serializing_if = "Option::is_none")]
1314    pub max_results: Option<i32>,
1315    #[serde(rename = "NextToken")]
1316    #[serde(default)]
1317    #[serde(skip_serializing_if = "Option::is_none")]
1318    pub next_token: Option<String>,
1319    #[serde(rename = "OperatingSystemNames")]
1320    #[serde(default)]
1321    #[serde(skip_serializing_if = "Option::is_none")]
1322    pub operating_system_names: Option<Vec<String>>,
1323    #[serde(rename = "Owner")]
1324    #[serde(default)]
1325    #[serde(skip_serializing_if = "Option::is_none")]
1326    pub owner: Option<String>,
1327}
1328
1329#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1330pub struct DescribeApplicationsResult {
1331    #[serde(rename = "Applications")]
1332    #[serde(default)]
1333    #[serde(skip_serializing_if = "Option::is_none")]
1334    pub applications: Option<Vec<WorkSpaceApplication>>,
1335    #[serde(rename = "NextToken")]
1336    #[serde(default)]
1337    #[serde(skip_serializing_if = "Option::is_none")]
1338    pub next_token: Option<String>,
1339}
1340
1341#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1342pub struct WorkSpaceApplication {
1343    #[serde(rename = "ApplicationId")]
1344    #[serde(default)]
1345    #[serde(skip_serializing_if = "Option::is_none")]
1346    pub application_id: Option<String>,
1347    #[serde(rename = "Created")]
1348    #[serde(default)]
1349    #[serde(skip_serializing_if = "Option::is_none")]
1350    pub created: Option<f64>,
1351    #[serde(rename = "Description")]
1352    #[serde(default)]
1353    #[serde(skip_serializing_if = "Option::is_none")]
1354    pub description: Option<String>,
1355    #[serde(rename = "LicenseType")]
1356    #[serde(default)]
1357    #[serde(skip_serializing_if = "Option::is_none")]
1358    pub license_type: Option<String>,
1359    #[serde(rename = "Name")]
1360    #[serde(default)]
1361    #[serde(skip_serializing_if = "Option::is_none")]
1362    pub name: Option<String>,
1363    #[serde(rename = "Owner")]
1364    #[serde(default)]
1365    #[serde(skip_serializing_if = "Option::is_none")]
1366    pub owner: Option<String>,
1367    #[serde(rename = "State")]
1368    #[serde(default)]
1369    #[serde(skip_serializing_if = "Option::is_none")]
1370    pub state: Option<String>,
1371    #[serde(rename = "SupportedComputeTypeNames")]
1372    #[serde(default)]
1373    #[serde(skip_serializing_if = "Option::is_none")]
1374    pub supported_compute_type_names: Option<Vec<String>>,
1375    #[serde(rename = "SupportedOperatingSystemNames")]
1376    #[serde(default)]
1377    #[serde(skip_serializing_if = "Option::is_none")]
1378    pub supported_operating_system_names: Option<Vec<String>>,
1379}
1380
1381#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1382pub struct DescribeBundleAssociationsRequest {
1383    #[serde(rename = "AssociatedResourceTypes")]
1384    #[serde(default)]
1385    pub associated_resource_types: Vec<String>,
1386    #[serde(rename = "BundleId")]
1387    #[serde(default)]
1388    pub bundle_id: String,
1389}
1390
1391#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1392pub struct DescribeBundleAssociationsResult {
1393    #[serde(rename = "Associations")]
1394    #[serde(default)]
1395    #[serde(skip_serializing_if = "Option::is_none")]
1396    pub associations: Option<Vec<BundleResourceAssociation>>,
1397}
1398
1399#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1400pub struct BundleResourceAssociation {
1401    #[serde(rename = "AssociatedResourceId")]
1402    #[serde(default)]
1403    #[serde(skip_serializing_if = "Option::is_none")]
1404    pub associated_resource_id: Option<String>,
1405    #[serde(rename = "AssociatedResourceType")]
1406    #[serde(default)]
1407    #[serde(skip_serializing_if = "Option::is_none")]
1408    pub associated_resource_type: Option<String>,
1409    #[serde(rename = "BundleId")]
1410    #[serde(default)]
1411    #[serde(skip_serializing_if = "Option::is_none")]
1412    pub bundle_id: Option<String>,
1413    #[serde(rename = "Created")]
1414    #[serde(default)]
1415    #[serde(skip_serializing_if = "Option::is_none")]
1416    pub created: Option<f64>,
1417    #[serde(rename = "LastUpdatedTime")]
1418    #[serde(default)]
1419    #[serde(skip_serializing_if = "Option::is_none")]
1420    pub last_updated_time: Option<f64>,
1421    #[serde(rename = "State")]
1422    #[serde(default)]
1423    #[serde(skip_serializing_if = "Option::is_none")]
1424    pub state: Option<String>,
1425    #[serde(rename = "StateReason")]
1426    #[serde(default)]
1427    #[serde(skip_serializing_if = "Option::is_none")]
1428    pub state_reason: Option<AssociationStateReason>,
1429}
1430
1431#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1432pub struct DescribeClientBrandingRequest {
1433    #[serde(rename = "ResourceId")]
1434    #[serde(default)]
1435    pub resource_id: String,
1436}
1437
1438#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1439pub struct DescribeClientBrandingResult {
1440    #[serde(rename = "DeviceTypeAndroid")]
1441    #[serde(default)]
1442    #[serde(skip_serializing_if = "Option::is_none")]
1443    pub device_type_android: Option<DefaultClientBrandingAttributes>,
1444    #[serde(rename = "DeviceTypeIos")]
1445    #[serde(default)]
1446    #[serde(skip_serializing_if = "Option::is_none")]
1447    pub device_type_ios: Option<IosClientBrandingAttributes>,
1448    #[serde(rename = "DeviceTypeLinux")]
1449    #[serde(default)]
1450    #[serde(skip_serializing_if = "Option::is_none")]
1451    pub device_type_linux: Option<DefaultClientBrandingAttributes>,
1452    #[serde(rename = "DeviceTypeOsx")]
1453    #[serde(default)]
1454    #[serde(skip_serializing_if = "Option::is_none")]
1455    pub device_type_osx: Option<DefaultClientBrandingAttributes>,
1456    #[serde(rename = "DeviceTypeWeb")]
1457    #[serde(default)]
1458    #[serde(skip_serializing_if = "Option::is_none")]
1459    pub device_type_web: Option<DefaultClientBrandingAttributes>,
1460    #[serde(rename = "DeviceTypeWindows")]
1461    #[serde(default)]
1462    #[serde(skip_serializing_if = "Option::is_none")]
1463    pub device_type_windows: Option<DefaultClientBrandingAttributes>,
1464}
1465
1466#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1467pub struct DefaultClientBrandingAttributes {
1468    #[serde(rename = "ForgotPasswordLink")]
1469    #[serde(default)]
1470    #[serde(skip_serializing_if = "Option::is_none")]
1471    pub forgot_password_link: Option<String>,
1472    #[serde(rename = "LoginMessage")]
1473    #[serde(default)]
1474    #[serde(skip_serializing_if = "Option::is_none")]
1475    pub login_message: Option<std::collections::HashMap<String, String>>,
1476    #[serde(rename = "LogoUrl")]
1477    #[serde(default)]
1478    #[serde(skip_serializing_if = "Option::is_none")]
1479    pub logo_url: Option<String>,
1480    #[serde(rename = "SupportEmail")]
1481    #[serde(default)]
1482    #[serde(skip_serializing_if = "Option::is_none")]
1483    pub support_email: Option<String>,
1484    #[serde(rename = "SupportLink")]
1485    #[serde(default)]
1486    #[serde(skip_serializing_if = "Option::is_none")]
1487    pub support_link: Option<String>,
1488}
1489
1490#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1491pub struct IosClientBrandingAttributes {
1492    #[serde(rename = "ForgotPasswordLink")]
1493    #[serde(default)]
1494    #[serde(skip_serializing_if = "Option::is_none")]
1495    pub forgot_password_link: Option<String>,
1496    #[serde(rename = "LoginMessage")]
1497    #[serde(default)]
1498    #[serde(skip_serializing_if = "Option::is_none")]
1499    pub login_message: Option<std::collections::HashMap<String, String>>,
1500    #[serde(rename = "Logo2xUrl")]
1501    #[serde(default)]
1502    #[serde(skip_serializing_if = "Option::is_none")]
1503    pub logo2x_url: Option<String>,
1504    #[serde(rename = "Logo3xUrl")]
1505    #[serde(default)]
1506    #[serde(skip_serializing_if = "Option::is_none")]
1507    pub logo3x_url: Option<String>,
1508    #[serde(rename = "LogoUrl")]
1509    #[serde(default)]
1510    #[serde(skip_serializing_if = "Option::is_none")]
1511    pub logo_url: Option<String>,
1512    #[serde(rename = "SupportEmail")]
1513    #[serde(default)]
1514    #[serde(skip_serializing_if = "Option::is_none")]
1515    pub support_email: Option<String>,
1516    #[serde(rename = "SupportLink")]
1517    #[serde(default)]
1518    #[serde(skip_serializing_if = "Option::is_none")]
1519    pub support_link: Option<String>,
1520}
1521
1522#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1523pub struct DescribeClientPropertiesRequest {
1524    #[serde(rename = "ResourceIds")]
1525    #[serde(default)]
1526    pub resource_ids: Vec<String>,
1527}
1528
1529#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1530pub struct DescribeClientPropertiesResult {
1531    #[serde(rename = "ClientPropertiesList")]
1532    #[serde(default)]
1533    #[serde(skip_serializing_if = "Option::is_none")]
1534    pub client_properties_list: Option<Vec<ClientPropertiesResult>>,
1535}
1536
1537#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1538pub struct ClientPropertiesResult {
1539    #[serde(rename = "ClientProperties")]
1540    #[serde(default)]
1541    #[serde(skip_serializing_if = "Option::is_none")]
1542    pub client_properties: Option<ClientProperties>,
1543    #[serde(rename = "ResourceId")]
1544    #[serde(default)]
1545    #[serde(skip_serializing_if = "Option::is_none")]
1546    pub resource_id: Option<String>,
1547}
1548
1549#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1550pub struct ClientProperties {
1551    #[serde(rename = "LogUploadEnabled")]
1552    #[serde(default)]
1553    #[serde(skip_serializing_if = "Option::is_none")]
1554    pub log_upload_enabled: Option<String>,
1555    #[serde(rename = "ReconnectEnabled")]
1556    #[serde(default)]
1557    #[serde(skip_serializing_if = "Option::is_none")]
1558    pub reconnect_enabled: Option<String>,
1559}
1560
1561#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1562pub struct DescribeConnectClientAddInsRequest {
1563    #[serde(rename = "MaxResults")]
1564    #[serde(default)]
1565    #[serde(skip_serializing_if = "Option::is_none")]
1566    pub max_results: Option<i32>,
1567    #[serde(rename = "NextToken")]
1568    #[serde(default)]
1569    #[serde(skip_serializing_if = "Option::is_none")]
1570    pub next_token: Option<String>,
1571    #[serde(rename = "ResourceId")]
1572    #[serde(default)]
1573    pub resource_id: String,
1574}
1575
1576#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1577pub struct DescribeConnectClientAddInsResult {
1578    #[serde(rename = "AddIns")]
1579    #[serde(default)]
1580    #[serde(skip_serializing_if = "Option::is_none")]
1581    pub add_ins: Option<Vec<ConnectClientAddIn>>,
1582    #[serde(rename = "NextToken")]
1583    #[serde(default)]
1584    #[serde(skip_serializing_if = "Option::is_none")]
1585    pub next_token: Option<String>,
1586}
1587
1588#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1589pub struct ConnectClientAddIn {
1590    #[serde(rename = "AddInId")]
1591    #[serde(default)]
1592    #[serde(skip_serializing_if = "Option::is_none")]
1593    pub add_in_id: Option<String>,
1594    #[serde(rename = "Name")]
1595    #[serde(default)]
1596    #[serde(skip_serializing_if = "Option::is_none")]
1597    pub name: Option<String>,
1598    #[serde(rename = "ResourceId")]
1599    #[serde(default)]
1600    #[serde(skip_serializing_if = "Option::is_none")]
1601    pub resource_id: Option<String>,
1602    #[serde(rename = "URL")]
1603    #[serde(default)]
1604    #[serde(skip_serializing_if = "Option::is_none")]
1605    pub u_r_l: Option<String>,
1606}
1607
1608#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1609pub struct DescribeConnectionAliasPermissionsRequest {
1610    #[serde(rename = "AliasId")]
1611    #[serde(default)]
1612    pub alias_id: String,
1613    #[serde(rename = "MaxResults")]
1614    #[serde(default)]
1615    #[serde(skip_serializing_if = "Option::is_none")]
1616    pub max_results: Option<i32>,
1617    #[serde(rename = "NextToken")]
1618    #[serde(default)]
1619    #[serde(skip_serializing_if = "Option::is_none")]
1620    pub next_token: Option<String>,
1621}
1622
1623#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1624pub struct DescribeConnectionAliasPermissionsResult {
1625    #[serde(rename = "AliasId")]
1626    #[serde(default)]
1627    #[serde(skip_serializing_if = "Option::is_none")]
1628    pub alias_id: Option<String>,
1629    #[serde(rename = "ConnectionAliasPermissions")]
1630    #[serde(default)]
1631    #[serde(skip_serializing_if = "Option::is_none")]
1632    pub connection_alias_permissions: Option<Vec<ConnectionAliasPermission>>,
1633    #[serde(rename = "NextToken")]
1634    #[serde(default)]
1635    #[serde(skip_serializing_if = "Option::is_none")]
1636    pub next_token: Option<String>,
1637}
1638
1639#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1640pub struct ConnectionAliasPermission {
1641    #[serde(rename = "AllowAssociation")]
1642    #[serde(default)]
1643    pub allow_association: bool,
1644    #[serde(rename = "SharedAccountId")]
1645    #[serde(default)]
1646    pub shared_account_id: String,
1647}
1648
1649#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1650pub struct DescribeConnectionAliasesRequest {
1651    #[serde(rename = "AliasIds")]
1652    #[serde(default)]
1653    #[serde(skip_serializing_if = "Option::is_none")]
1654    pub alias_ids: Option<Vec<String>>,
1655    #[serde(rename = "Limit")]
1656    #[serde(default)]
1657    #[serde(skip_serializing_if = "Option::is_none")]
1658    pub limit: Option<i32>,
1659    #[serde(rename = "NextToken")]
1660    #[serde(default)]
1661    #[serde(skip_serializing_if = "Option::is_none")]
1662    pub next_token: Option<String>,
1663    #[serde(rename = "ResourceId")]
1664    #[serde(default)]
1665    #[serde(skip_serializing_if = "Option::is_none")]
1666    pub resource_id: Option<String>,
1667}
1668
1669#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1670pub struct DescribeConnectionAliasesResult {
1671    #[serde(rename = "ConnectionAliases")]
1672    #[serde(default)]
1673    #[serde(skip_serializing_if = "Option::is_none")]
1674    pub connection_aliases: Option<Vec<ConnectionAlias>>,
1675    #[serde(rename = "NextToken")]
1676    #[serde(default)]
1677    #[serde(skip_serializing_if = "Option::is_none")]
1678    pub next_token: Option<String>,
1679}
1680
1681#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1682pub struct ConnectionAlias {
1683    #[serde(rename = "AliasId")]
1684    #[serde(default)]
1685    #[serde(skip_serializing_if = "Option::is_none")]
1686    pub alias_id: Option<String>,
1687    #[serde(rename = "Associations")]
1688    #[serde(default)]
1689    #[serde(skip_serializing_if = "Option::is_none")]
1690    pub associations: Option<Vec<ConnectionAliasAssociation>>,
1691    #[serde(rename = "ConnectionString")]
1692    #[serde(default)]
1693    #[serde(skip_serializing_if = "Option::is_none")]
1694    pub connection_string: Option<String>,
1695    #[serde(rename = "OwnerAccountId")]
1696    #[serde(default)]
1697    #[serde(skip_serializing_if = "Option::is_none")]
1698    pub owner_account_id: Option<String>,
1699    #[serde(rename = "State")]
1700    #[serde(default)]
1701    #[serde(skip_serializing_if = "Option::is_none")]
1702    pub state: Option<String>,
1703}
1704
1705#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1706pub struct ConnectionAliasAssociation {
1707    #[serde(rename = "AssociatedAccountId")]
1708    #[serde(default)]
1709    #[serde(skip_serializing_if = "Option::is_none")]
1710    pub associated_account_id: Option<String>,
1711    #[serde(rename = "AssociationStatus")]
1712    #[serde(default)]
1713    #[serde(skip_serializing_if = "Option::is_none")]
1714    pub association_status: Option<String>,
1715    #[serde(rename = "ConnectionIdentifier")]
1716    #[serde(default)]
1717    #[serde(skip_serializing_if = "Option::is_none")]
1718    pub connection_identifier: Option<String>,
1719    #[serde(rename = "ResourceId")]
1720    #[serde(default)]
1721    #[serde(skip_serializing_if = "Option::is_none")]
1722    pub resource_id: Option<String>,
1723}
1724
1725#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1726pub struct DescribeCustomWorkspaceImageImportRequest {
1727    #[serde(rename = "ImageId")]
1728    #[serde(default)]
1729    pub image_id: String,
1730}
1731
1732#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1733pub struct DescribeCustomWorkspaceImageImportResult {
1734    #[serde(rename = "Created")]
1735    #[serde(default)]
1736    #[serde(skip_serializing_if = "Option::is_none")]
1737    pub created: Option<f64>,
1738    #[serde(rename = "ErrorDetails")]
1739    #[serde(default)]
1740    #[serde(skip_serializing_if = "Option::is_none")]
1741    pub error_details: Option<Vec<CustomWorkspaceImageImportErrorDetails>>,
1742    #[serde(rename = "ImageBuilderInstanceId")]
1743    #[serde(default)]
1744    #[serde(skip_serializing_if = "Option::is_none")]
1745    pub image_builder_instance_id: Option<String>,
1746    #[serde(rename = "ImageId")]
1747    #[serde(default)]
1748    #[serde(skip_serializing_if = "Option::is_none")]
1749    pub image_id: Option<String>,
1750    #[serde(rename = "ImageSource")]
1751    #[serde(default)]
1752    #[serde(skip_serializing_if = "Option::is_none")]
1753    pub image_source: Option<ImageSourceIdentifier>,
1754    #[serde(rename = "InfrastructureConfigurationArn")]
1755    #[serde(default)]
1756    #[serde(skip_serializing_if = "Option::is_none")]
1757    pub infrastructure_configuration_arn: Option<String>,
1758    #[serde(rename = "LastUpdatedTime")]
1759    #[serde(default)]
1760    #[serde(skip_serializing_if = "Option::is_none")]
1761    pub last_updated_time: Option<f64>,
1762    #[serde(rename = "ProgressPercentage")]
1763    #[serde(default)]
1764    #[serde(skip_serializing_if = "Option::is_none")]
1765    pub progress_percentage: Option<i32>,
1766    #[serde(rename = "State")]
1767    #[serde(default)]
1768    #[serde(skip_serializing_if = "Option::is_none")]
1769    pub state: Option<String>,
1770    #[serde(rename = "StateMessage")]
1771    #[serde(default)]
1772    #[serde(skip_serializing_if = "Option::is_none")]
1773    pub state_message: Option<String>,
1774}
1775
1776#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1777pub struct CustomWorkspaceImageImportErrorDetails {
1778    #[serde(rename = "ErrorCode")]
1779    #[serde(default)]
1780    #[serde(skip_serializing_if = "Option::is_none")]
1781    pub error_code: Option<String>,
1782    #[serde(rename = "ErrorMessage")]
1783    #[serde(default)]
1784    #[serde(skip_serializing_if = "Option::is_none")]
1785    pub error_message: Option<String>,
1786}
1787
1788#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1789pub struct ImageSourceIdentifier {
1790    #[serde(rename = "Ec2ImageId")]
1791    #[serde(default)]
1792    #[serde(skip_serializing_if = "Option::is_none")]
1793    pub ec2_image_id: Option<String>,
1794    #[serde(rename = "Ec2ImportTaskId")]
1795    #[serde(default)]
1796    #[serde(skip_serializing_if = "Option::is_none")]
1797    pub ec2_import_task_id: Option<String>,
1798    #[serde(rename = "ImageBuildVersionArn")]
1799    #[serde(default)]
1800    #[serde(skip_serializing_if = "Option::is_none")]
1801    pub image_build_version_arn: Option<String>,
1802}
1803
1804#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1805pub struct DescribeImageAssociationsRequest {
1806    #[serde(rename = "AssociatedResourceTypes")]
1807    #[serde(default)]
1808    pub associated_resource_types: Vec<String>,
1809    #[serde(rename = "ImageId")]
1810    #[serde(default)]
1811    pub image_id: String,
1812}
1813
1814#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1815pub struct DescribeImageAssociationsResult {
1816    #[serde(rename = "Associations")]
1817    #[serde(default)]
1818    #[serde(skip_serializing_if = "Option::is_none")]
1819    pub associations: Option<Vec<ImageResourceAssociation>>,
1820}
1821
1822#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1823pub struct ImageResourceAssociation {
1824    #[serde(rename = "AssociatedResourceId")]
1825    #[serde(default)]
1826    #[serde(skip_serializing_if = "Option::is_none")]
1827    pub associated_resource_id: Option<String>,
1828    #[serde(rename = "AssociatedResourceType")]
1829    #[serde(default)]
1830    #[serde(skip_serializing_if = "Option::is_none")]
1831    pub associated_resource_type: Option<String>,
1832    #[serde(rename = "Created")]
1833    #[serde(default)]
1834    #[serde(skip_serializing_if = "Option::is_none")]
1835    pub created: Option<f64>,
1836    #[serde(rename = "ImageId")]
1837    #[serde(default)]
1838    #[serde(skip_serializing_if = "Option::is_none")]
1839    pub image_id: Option<String>,
1840    #[serde(rename = "LastUpdatedTime")]
1841    #[serde(default)]
1842    #[serde(skip_serializing_if = "Option::is_none")]
1843    pub last_updated_time: Option<f64>,
1844    #[serde(rename = "State")]
1845    #[serde(default)]
1846    #[serde(skip_serializing_if = "Option::is_none")]
1847    pub state: Option<String>,
1848    #[serde(rename = "StateReason")]
1849    #[serde(default)]
1850    #[serde(skip_serializing_if = "Option::is_none")]
1851    pub state_reason: Option<AssociationStateReason>,
1852}
1853
1854#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1855pub struct DescribeIpGroupsRequest {
1856    #[serde(rename = "GroupIds")]
1857    #[serde(default)]
1858    #[serde(skip_serializing_if = "Option::is_none")]
1859    pub group_ids: Option<Vec<String>>,
1860    #[serde(rename = "MaxResults")]
1861    #[serde(default)]
1862    #[serde(skip_serializing_if = "Option::is_none")]
1863    pub max_results: Option<i32>,
1864    #[serde(rename = "NextToken")]
1865    #[serde(default)]
1866    #[serde(skip_serializing_if = "Option::is_none")]
1867    pub next_token: Option<String>,
1868}
1869
1870#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1871pub struct DescribeIpGroupsResult {
1872    #[serde(rename = "NextToken")]
1873    #[serde(default)]
1874    #[serde(skip_serializing_if = "Option::is_none")]
1875    pub next_token: Option<String>,
1876    #[serde(rename = "Result")]
1877    #[serde(default)]
1878    #[serde(skip_serializing_if = "Option::is_none")]
1879    pub result: Option<Vec<WorkspacesIpGroup>>,
1880}
1881
1882#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1883pub struct WorkspacesIpGroup {
1884    #[serde(rename = "groupDesc")]
1885    #[serde(default)]
1886    #[serde(skip_serializing_if = "Option::is_none")]
1887    pub group_desc: Option<String>,
1888    #[serde(rename = "groupId")]
1889    #[serde(default)]
1890    #[serde(skip_serializing_if = "Option::is_none")]
1891    pub group_id: Option<String>,
1892    #[serde(rename = "groupName")]
1893    #[serde(default)]
1894    #[serde(skip_serializing_if = "Option::is_none")]
1895    pub group_name: Option<String>,
1896    #[serde(rename = "userRules")]
1897    #[serde(default)]
1898    #[serde(skip_serializing_if = "Option::is_none")]
1899    pub user_rules: Option<Vec<IpRuleItem>>,
1900}
1901
1902#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1903pub struct DescribeTagsRequest {
1904    #[serde(rename = "ResourceId")]
1905    #[serde(default)]
1906    pub resource_id: String,
1907}
1908
1909#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1910pub struct DescribeTagsResult {
1911    #[serde(rename = "TagList")]
1912    #[serde(default)]
1913    #[serde(skip_serializing_if = "Option::is_none")]
1914    pub tag_list: Option<Vec<Tag>>,
1915}
1916
1917#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1918pub struct DescribeWorkspaceAssociationsRequest {
1919    #[serde(rename = "AssociatedResourceTypes")]
1920    #[serde(default)]
1921    pub associated_resource_types: Vec<String>,
1922    #[serde(rename = "WorkspaceId")]
1923    #[serde(default)]
1924    pub workspace_id: String,
1925}
1926
1927#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1928pub struct DescribeWorkspaceAssociationsResult {
1929    #[serde(rename = "Associations")]
1930    #[serde(default)]
1931    #[serde(skip_serializing_if = "Option::is_none")]
1932    pub associations: Option<Vec<WorkspaceResourceAssociation>>,
1933}
1934
1935#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1936pub struct DescribeWorkspaceBundlesRequest {
1937    #[serde(rename = "BundleIds")]
1938    #[serde(default)]
1939    #[serde(skip_serializing_if = "Option::is_none")]
1940    pub bundle_ids: Option<Vec<String>>,
1941    #[serde(rename = "NextToken")]
1942    #[serde(default)]
1943    #[serde(skip_serializing_if = "Option::is_none")]
1944    pub next_token: Option<String>,
1945    #[serde(rename = "Owner")]
1946    #[serde(default)]
1947    #[serde(skip_serializing_if = "Option::is_none")]
1948    pub owner: Option<String>,
1949}
1950
1951#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1952pub struct DescribeWorkspaceBundlesResult {
1953    #[serde(rename = "Bundles")]
1954    #[serde(default)]
1955    #[serde(skip_serializing_if = "Option::is_none")]
1956    pub bundles: Option<Vec<WorkspaceBundle>>,
1957    #[serde(rename = "NextToken")]
1958    #[serde(default)]
1959    #[serde(skip_serializing_if = "Option::is_none")]
1960    pub next_token: Option<String>,
1961}
1962
1963#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1964pub struct DescribeWorkspaceDirectoriesRequest {
1965    #[serde(rename = "DirectoryIds")]
1966    #[serde(default)]
1967    #[serde(skip_serializing_if = "Option::is_none")]
1968    pub directory_ids: Option<Vec<String>>,
1969    #[serde(rename = "Filters")]
1970    #[serde(default)]
1971    #[serde(skip_serializing_if = "Option::is_none")]
1972    pub filters: Option<Vec<DescribeWorkspaceDirectoriesFilter>>,
1973    #[serde(rename = "Limit")]
1974    #[serde(default)]
1975    #[serde(skip_serializing_if = "Option::is_none")]
1976    pub limit: Option<i32>,
1977    #[serde(rename = "NextToken")]
1978    #[serde(default)]
1979    #[serde(skip_serializing_if = "Option::is_none")]
1980    pub next_token: Option<String>,
1981    #[serde(rename = "WorkspaceDirectoryNames")]
1982    #[serde(default)]
1983    #[serde(skip_serializing_if = "Option::is_none")]
1984    pub workspace_directory_names: Option<Vec<String>>,
1985}
1986
1987#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1988pub struct DescribeWorkspaceDirectoriesFilter {
1989    #[serde(rename = "Name")]
1990    #[serde(default)]
1991    pub name: String,
1992    #[serde(rename = "Values")]
1993    #[serde(default)]
1994    pub values: Vec<String>,
1995}
1996
1997#[derive(Debug, Clone, Default, Deserialize, Serialize)]
1998pub struct DescribeWorkspaceDirectoriesResult {
1999    #[serde(rename = "Directories")]
2000    #[serde(default)]
2001    #[serde(skip_serializing_if = "Option::is_none")]
2002    pub directories: Option<Vec<WorkspaceDirectory>>,
2003    #[serde(rename = "NextToken")]
2004    #[serde(default)]
2005    #[serde(skip_serializing_if = "Option::is_none")]
2006    pub next_token: Option<String>,
2007}
2008
2009#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2010pub struct WorkspaceDirectory {
2011    #[serde(rename = "ActiveDirectoryConfig")]
2012    #[serde(default)]
2013    #[serde(skip_serializing_if = "Option::is_none")]
2014    pub active_directory_config: Option<ActiveDirectoryConfig>,
2015    #[serde(rename = "Alias")]
2016    #[serde(default)]
2017    #[serde(skip_serializing_if = "Option::is_none")]
2018    pub alias: Option<String>,
2019    #[serde(rename = "CertificateBasedAuthProperties")]
2020    #[serde(default)]
2021    #[serde(skip_serializing_if = "Option::is_none")]
2022    pub certificate_based_auth_properties: Option<CertificateBasedAuthProperties>,
2023    #[serde(rename = "CustomerUserName")]
2024    #[serde(default)]
2025    #[serde(skip_serializing_if = "Option::is_none")]
2026    pub customer_user_name: Option<String>,
2027    #[serde(rename = "DirectoryId")]
2028    #[serde(default)]
2029    #[serde(skip_serializing_if = "Option::is_none")]
2030    pub directory_id: Option<String>,
2031    #[serde(rename = "DirectoryName")]
2032    #[serde(default)]
2033    #[serde(skip_serializing_if = "Option::is_none")]
2034    pub directory_name: Option<String>,
2035    #[serde(rename = "DirectoryType")]
2036    #[serde(default)]
2037    #[serde(skip_serializing_if = "Option::is_none")]
2038    pub directory_type: Option<String>,
2039    #[serde(rename = "DnsIpAddresses")]
2040    #[serde(default)]
2041    #[serde(skip_serializing_if = "Option::is_none")]
2042    pub dns_ip_addresses: Option<Vec<String>>,
2043    #[serde(rename = "DnsIpv6Addresses")]
2044    #[serde(default)]
2045    #[serde(skip_serializing_if = "Option::is_none")]
2046    pub dns_ipv6_addresses: Option<Vec<String>>,
2047    #[serde(rename = "EndpointEncryptionMode")]
2048    #[serde(default)]
2049    #[serde(skip_serializing_if = "Option::is_none")]
2050    pub endpoint_encryption_mode: Option<String>,
2051    #[serde(rename = "ErrorMessage")]
2052    #[serde(default)]
2053    #[serde(skip_serializing_if = "Option::is_none")]
2054    pub error_message: Option<String>,
2055    #[serde(rename = "IDCConfig")]
2056    #[serde(default)]
2057    #[serde(skip_serializing_if = "Option::is_none")]
2058    pub i_d_c_config: Option<IDCConfig>,
2059    #[serde(rename = "IamRoleId")]
2060    #[serde(default)]
2061    #[serde(skip_serializing_if = "Option::is_none")]
2062    pub iam_role_id: Option<String>,
2063    #[serde(rename = "MicrosoftEntraConfig")]
2064    #[serde(default)]
2065    #[serde(skip_serializing_if = "Option::is_none")]
2066    pub microsoft_entra_config: Option<MicrosoftEntraConfig>,
2067    #[serde(rename = "RegistrationCode")]
2068    #[serde(default)]
2069    #[serde(skip_serializing_if = "Option::is_none")]
2070    pub registration_code: Option<String>,
2071    #[serde(rename = "SamlProperties")]
2072    #[serde(default)]
2073    #[serde(skip_serializing_if = "Option::is_none")]
2074    pub saml_properties: Option<SamlProperties>,
2075    #[serde(rename = "SelfservicePermissions")]
2076    #[serde(default)]
2077    #[serde(skip_serializing_if = "Option::is_none")]
2078    pub selfservice_permissions: Option<SelfservicePermissions>,
2079    #[serde(rename = "State")]
2080    #[serde(default)]
2081    #[serde(skip_serializing_if = "Option::is_none")]
2082    pub state: Option<String>,
2083    #[serde(rename = "StreamingProperties")]
2084    #[serde(default)]
2085    #[serde(skip_serializing_if = "Option::is_none")]
2086    pub streaming_properties: Option<StreamingProperties>,
2087    #[serde(rename = "SubnetIds")]
2088    #[serde(default)]
2089    #[serde(skip_serializing_if = "Option::is_none")]
2090    pub subnet_ids: Option<Vec<String>>,
2091    #[serde(rename = "Tenancy")]
2092    #[serde(default)]
2093    #[serde(skip_serializing_if = "Option::is_none")]
2094    pub tenancy: Option<String>,
2095    #[serde(rename = "UserIdentityType")]
2096    #[serde(default)]
2097    #[serde(skip_serializing_if = "Option::is_none")]
2098    pub user_identity_type: Option<String>,
2099    #[serde(rename = "WorkspaceAccessProperties")]
2100    #[serde(default)]
2101    #[serde(skip_serializing_if = "Option::is_none")]
2102    pub workspace_access_properties: Option<WorkspaceAccessProperties>,
2103    #[serde(rename = "WorkspaceCreationProperties")]
2104    #[serde(default)]
2105    #[serde(skip_serializing_if = "Option::is_none")]
2106    pub workspace_creation_properties: Option<DefaultWorkspaceCreationProperties>,
2107    #[serde(rename = "WorkspaceDirectoryDescription")]
2108    #[serde(default)]
2109    #[serde(skip_serializing_if = "Option::is_none")]
2110    pub workspace_directory_description: Option<String>,
2111    #[serde(rename = "WorkspaceDirectoryName")]
2112    #[serde(default)]
2113    #[serde(skip_serializing_if = "Option::is_none")]
2114    pub workspace_directory_name: Option<String>,
2115    #[serde(rename = "WorkspaceSecurityGroupId")]
2116    #[serde(default)]
2117    #[serde(skip_serializing_if = "Option::is_none")]
2118    pub workspace_security_group_id: Option<String>,
2119    #[serde(rename = "WorkspaceType")]
2120    #[serde(default)]
2121    #[serde(skip_serializing_if = "Option::is_none")]
2122    pub workspace_type: Option<String>,
2123    #[serde(rename = "ipGroupIds")]
2124    #[serde(default)]
2125    #[serde(skip_serializing_if = "Option::is_none")]
2126    pub ip_group_ids: Option<Vec<String>>,
2127}
2128
2129#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2130pub struct ActiveDirectoryConfig {
2131    #[serde(rename = "DomainName")]
2132    #[serde(default)]
2133    pub domain_name: String,
2134    #[serde(rename = "ServiceAccountSecretArn")]
2135    #[serde(default)]
2136    pub service_account_secret_arn: String,
2137}
2138
2139#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2140pub struct CertificateBasedAuthProperties {
2141    #[serde(rename = "CertificateAuthorityArn")]
2142    #[serde(default)]
2143    #[serde(skip_serializing_if = "Option::is_none")]
2144    pub certificate_authority_arn: Option<String>,
2145    #[serde(rename = "Status")]
2146    #[serde(default)]
2147    #[serde(skip_serializing_if = "Option::is_none")]
2148    pub status: Option<String>,
2149}
2150
2151#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2152pub struct IDCConfig {
2153    #[serde(rename = "ApplicationArn")]
2154    #[serde(default)]
2155    #[serde(skip_serializing_if = "Option::is_none")]
2156    pub application_arn: Option<String>,
2157    #[serde(rename = "InstanceArn")]
2158    #[serde(default)]
2159    #[serde(skip_serializing_if = "Option::is_none")]
2160    pub instance_arn: Option<String>,
2161}
2162
2163#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2164pub struct MicrosoftEntraConfig {
2165    #[serde(rename = "ApplicationConfigSecretArn")]
2166    #[serde(default)]
2167    #[serde(skip_serializing_if = "Option::is_none")]
2168    pub application_config_secret_arn: Option<String>,
2169    #[serde(rename = "TenantId")]
2170    #[serde(default)]
2171    #[serde(skip_serializing_if = "Option::is_none")]
2172    pub tenant_id: Option<String>,
2173}
2174
2175#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2176pub struct SamlProperties {
2177    #[serde(rename = "RelayStateParameterName")]
2178    #[serde(default)]
2179    #[serde(skip_serializing_if = "Option::is_none")]
2180    pub relay_state_parameter_name: Option<String>,
2181    #[serde(rename = "Status")]
2182    #[serde(default)]
2183    #[serde(skip_serializing_if = "Option::is_none")]
2184    pub status: Option<String>,
2185    #[serde(rename = "UserAccessUrl")]
2186    #[serde(default)]
2187    #[serde(skip_serializing_if = "Option::is_none")]
2188    pub user_access_url: Option<String>,
2189}
2190
2191#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2192pub struct SelfservicePermissions {
2193    #[serde(rename = "ChangeComputeType")]
2194    #[serde(default)]
2195    #[serde(skip_serializing_if = "Option::is_none")]
2196    pub change_compute_type: Option<String>,
2197    #[serde(rename = "IncreaseVolumeSize")]
2198    #[serde(default)]
2199    #[serde(skip_serializing_if = "Option::is_none")]
2200    pub increase_volume_size: Option<String>,
2201    #[serde(rename = "RebuildWorkspace")]
2202    #[serde(default)]
2203    #[serde(skip_serializing_if = "Option::is_none")]
2204    pub rebuild_workspace: Option<String>,
2205    #[serde(rename = "RestartWorkspace")]
2206    #[serde(default)]
2207    #[serde(skip_serializing_if = "Option::is_none")]
2208    pub restart_workspace: Option<String>,
2209    #[serde(rename = "SwitchRunningMode")]
2210    #[serde(default)]
2211    #[serde(skip_serializing_if = "Option::is_none")]
2212    pub switch_running_mode: Option<String>,
2213}
2214
2215#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2216pub struct StreamingProperties {
2217    #[serde(rename = "GlobalAccelerator")]
2218    #[serde(default)]
2219    #[serde(skip_serializing_if = "Option::is_none")]
2220    pub global_accelerator: Option<GlobalAcceleratorForDirectory>,
2221    #[serde(rename = "StorageConnectors")]
2222    #[serde(default)]
2223    #[serde(skip_serializing_if = "Option::is_none")]
2224    pub storage_connectors: Option<Vec<StorageConnector>>,
2225    #[serde(rename = "StreamingExperiencePreferredProtocol")]
2226    #[serde(default)]
2227    #[serde(skip_serializing_if = "Option::is_none")]
2228    pub streaming_experience_preferred_protocol: Option<String>,
2229    #[serde(rename = "UserSettings")]
2230    #[serde(default)]
2231    #[serde(skip_serializing_if = "Option::is_none")]
2232    pub user_settings: Option<Vec<UserSetting>>,
2233}
2234
2235#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2236pub struct GlobalAcceleratorForDirectory {
2237    #[serde(rename = "Mode")]
2238    #[serde(default)]
2239    pub mode: String,
2240    #[serde(rename = "PreferredProtocol")]
2241    #[serde(default)]
2242    #[serde(skip_serializing_if = "Option::is_none")]
2243    pub preferred_protocol: Option<String>,
2244}
2245
2246#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2247pub struct StorageConnector {
2248    #[serde(rename = "ConnectorType")]
2249    #[serde(default)]
2250    pub connector_type: String,
2251    #[serde(rename = "Status")]
2252    #[serde(default)]
2253    pub status: String,
2254}
2255
2256#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2257pub struct UserSetting {
2258    #[serde(rename = "Action")]
2259    #[serde(default)]
2260    pub action: String,
2261    #[serde(rename = "MaximumLength")]
2262    #[serde(default)]
2263    #[serde(skip_serializing_if = "Option::is_none")]
2264    pub maximum_length: Option<i32>,
2265    #[serde(rename = "Permission")]
2266    #[serde(default)]
2267    pub permission: String,
2268}
2269
2270#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2271pub struct WorkspaceAccessProperties {
2272    #[serde(rename = "AccessEndpointConfig")]
2273    #[serde(default)]
2274    #[serde(skip_serializing_if = "Option::is_none")]
2275    pub access_endpoint_config: Option<AccessEndpointConfig>,
2276    #[serde(rename = "DeviceTypeAndroid")]
2277    #[serde(default)]
2278    #[serde(skip_serializing_if = "Option::is_none")]
2279    pub device_type_android: Option<String>,
2280    #[serde(rename = "DeviceTypeChromeOs")]
2281    #[serde(default)]
2282    #[serde(skip_serializing_if = "Option::is_none")]
2283    pub device_type_chrome_os: Option<String>,
2284    #[serde(rename = "DeviceTypeIos")]
2285    #[serde(default)]
2286    #[serde(skip_serializing_if = "Option::is_none")]
2287    pub device_type_ios: Option<String>,
2288    #[serde(rename = "DeviceTypeLinux")]
2289    #[serde(default)]
2290    #[serde(skip_serializing_if = "Option::is_none")]
2291    pub device_type_linux: Option<String>,
2292    #[serde(rename = "DeviceTypeOsx")]
2293    #[serde(default)]
2294    #[serde(skip_serializing_if = "Option::is_none")]
2295    pub device_type_osx: Option<String>,
2296    #[serde(rename = "DeviceTypeWeb")]
2297    #[serde(default)]
2298    #[serde(skip_serializing_if = "Option::is_none")]
2299    pub device_type_web: Option<String>,
2300    #[serde(rename = "DeviceTypeWindows")]
2301    #[serde(default)]
2302    #[serde(skip_serializing_if = "Option::is_none")]
2303    pub device_type_windows: Option<String>,
2304    #[serde(rename = "DeviceTypeWorkSpacesThinClient")]
2305    #[serde(default)]
2306    #[serde(skip_serializing_if = "Option::is_none")]
2307    pub device_type_work_spaces_thin_client: Option<String>,
2308    #[serde(rename = "DeviceTypeZeroClient")]
2309    #[serde(default)]
2310    #[serde(skip_serializing_if = "Option::is_none")]
2311    pub device_type_zero_client: Option<String>,
2312}
2313
2314#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2315pub struct AccessEndpointConfig {
2316    #[serde(rename = "AccessEndpoints")]
2317    #[serde(default)]
2318    pub access_endpoints: Vec<AccessEndpoint>,
2319    #[serde(rename = "InternetFallbackProtocols")]
2320    #[serde(default)]
2321    #[serde(skip_serializing_if = "Option::is_none")]
2322    pub internet_fallback_protocols: Option<Vec<String>>,
2323}
2324
2325#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2326pub struct AccessEndpoint {
2327    #[serde(rename = "AccessEndpointType")]
2328    #[serde(default)]
2329    #[serde(skip_serializing_if = "Option::is_none")]
2330    pub access_endpoint_type: Option<String>,
2331    #[serde(rename = "VpcEndpointId")]
2332    #[serde(default)]
2333    #[serde(skip_serializing_if = "Option::is_none")]
2334    pub vpc_endpoint_id: Option<String>,
2335}
2336
2337#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2338pub struct DefaultWorkspaceCreationProperties {
2339    #[serde(rename = "CustomSecurityGroupId")]
2340    #[serde(default)]
2341    #[serde(skip_serializing_if = "Option::is_none")]
2342    pub custom_security_group_id: Option<String>,
2343    #[serde(rename = "DefaultOu")]
2344    #[serde(default)]
2345    #[serde(skip_serializing_if = "Option::is_none")]
2346    pub default_ou: Option<String>,
2347    #[serde(rename = "EnableInternetAccess")]
2348    #[serde(default)]
2349    #[serde(skip_serializing_if = "Option::is_none")]
2350    pub enable_internet_access: Option<bool>,
2351    #[serde(rename = "EnableMaintenanceMode")]
2352    #[serde(default)]
2353    #[serde(skip_serializing_if = "Option::is_none")]
2354    pub enable_maintenance_mode: Option<bool>,
2355    #[serde(rename = "InstanceIamRoleArn")]
2356    #[serde(default)]
2357    #[serde(skip_serializing_if = "Option::is_none")]
2358    pub instance_iam_role_arn: Option<String>,
2359    #[serde(rename = "UserEnabledAsLocalAdministrator")]
2360    #[serde(default)]
2361    #[serde(skip_serializing_if = "Option::is_none")]
2362    pub user_enabled_as_local_administrator: Option<bool>,
2363}
2364
2365#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2366pub struct DescribeWorkspaceImagePermissionsRequest {
2367    #[serde(rename = "ImageId")]
2368    #[serde(default)]
2369    pub image_id: String,
2370    #[serde(rename = "MaxResults")]
2371    #[serde(default)]
2372    #[serde(skip_serializing_if = "Option::is_none")]
2373    pub max_results: Option<i32>,
2374    #[serde(rename = "NextToken")]
2375    #[serde(default)]
2376    #[serde(skip_serializing_if = "Option::is_none")]
2377    pub next_token: Option<String>,
2378}
2379
2380#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2381pub struct DescribeWorkspaceImagePermissionsResult {
2382    #[serde(rename = "ImageId")]
2383    #[serde(default)]
2384    #[serde(skip_serializing_if = "Option::is_none")]
2385    pub image_id: Option<String>,
2386    #[serde(rename = "ImagePermissions")]
2387    #[serde(default)]
2388    #[serde(skip_serializing_if = "Option::is_none")]
2389    pub image_permissions: Option<Vec<ImagePermission>>,
2390    #[serde(rename = "NextToken")]
2391    #[serde(default)]
2392    #[serde(skip_serializing_if = "Option::is_none")]
2393    pub next_token: Option<String>,
2394}
2395
2396#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2397pub struct ImagePermission {
2398    #[serde(rename = "SharedAccountId")]
2399    #[serde(default)]
2400    #[serde(skip_serializing_if = "Option::is_none")]
2401    pub shared_account_id: Option<String>,
2402}
2403
2404#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2405pub struct DescribeWorkspaceImagesRequest {
2406    #[serde(rename = "ImageIds")]
2407    #[serde(default)]
2408    #[serde(skip_serializing_if = "Option::is_none")]
2409    pub image_ids: Option<Vec<String>>,
2410    #[serde(rename = "ImageType")]
2411    #[serde(default)]
2412    #[serde(skip_serializing_if = "Option::is_none")]
2413    pub image_type: Option<String>,
2414    #[serde(rename = "MaxResults")]
2415    #[serde(default)]
2416    #[serde(skip_serializing_if = "Option::is_none")]
2417    pub max_results: Option<i32>,
2418    #[serde(rename = "NextToken")]
2419    #[serde(default)]
2420    #[serde(skip_serializing_if = "Option::is_none")]
2421    pub next_token: Option<String>,
2422}
2423
2424#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2425pub struct DescribeWorkspaceImagesResult {
2426    #[serde(rename = "Images")]
2427    #[serde(default)]
2428    #[serde(skip_serializing_if = "Option::is_none")]
2429    pub images: Option<Vec<WorkspaceImage>>,
2430    #[serde(rename = "NextToken")]
2431    #[serde(default)]
2432    #[serde(skip_serializing_if = "Option::is_none")]
2433    pub next_token: Option<String>,
2434}
2435
2436#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2437pub struct WorkspaceImage {
2438    #[serde(rename = "Created")]
2439    #[serde(default)]
2440    #[serde(skip_serializing_if = "Option::is_none")]
2441    pub created: Option<f64>,
2442    #[serde(rename = "Description")]
2443    #[serde(default)]
2444    #[serde(skip_serializing_if = "Option::is_none")]
2445    pub description: Option<String>,
2446    #[serde(rename = "ErrorCode")]
2447    #[serde(default)]
2448    #[serde(skip_serializing_if = "Option::is_none")]
2449    pub error_code: Option<String>,
2450    #[serde(rename = "ErrorDetails")]
2451    #[serde(default)]
2452    #[serde(skip_serializing_if = "Option::is_none")]
2453    pub error_details: Option<Vec<ErrorDetails>>,
2454    #[serde(rename = "ErrorMessage")]
2455    #[serde(default)]
2456    #[serde(skip_serializing_if = "Option::is_none")]
2457    pub error_message: Option<String>,
2458    #[serde(rename = "ImageId")]
2459    #[serde(default)]
2460    #[serde(skip_serializing_if = "Option::is_none")]
2461    pub image_id: Option<String>,
2462    #[serde(rename = "Name")]
2463    #[serde(default)]
2464    #[serde(skip_serializing_if = "Option::is_none")]
2465    pub name: Option<String>,
2466    #[serde(rename = "OperatingSystem")]
2467    #[serde(default)]
2468    #[serde(skip_serializing_if = "Option::is_none")]
2469    pub operating_system: Option<OperatingSystem>,
2470    #[serde(rename = "OwnerAccountId")]
2471    #[serde(default)]
2472    #[serde(skip_serializing_if = "Option::is_none")]
2473    pub owner_account_id: Option<String>,
2474    #[serde(rename = "RequiredTenancy")]
2475    #[serde(default)]
2476    #[serde(skip_serializing_if = "Option::is_none")]
2477    pub required_tenancy: Option<String>,
2478    #[serde(rename = "State")]
2479    #[serde(default)]
2480    #[serde(skip_serializing_if = "Option::is_none")]
2481    pub state: Option<String>,
2482    #[serde(rename = "Updates")]
2483    #[serde(default)]
2484    #[serde(skip_serializing_if = "Option::is_none")]
2485    pub updates: Option<UpdateResult>,
2486}
2487
2488#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2489pub struct ErrorDetails {
2490    #[serde(rename = "ErrorCode")]
2491    #[serde(default)]
2492    #[serde(skip_serializing_if = "Option::is_none")]
2493    pub error_code: Option<String>,
2494    #[serde(rename = "ErrorMessage")]
2495    #[serde(default)]
2496    #[serde(skip_serializing_if = "Option::is_none")]
2497    pub error_message: Option<String>,
2498}
2499
2500#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2501pub struct UpdateResult {
2502    #[serde(rename = "Description")]
2503    #[serde(default)]
2504    #[serde(skip_serializing_if = "Option::is_none")]
2505    pub description: Option<String>,
2506    #[serde(rename = "UpdateAvailable")]
2507    #[serde(default)]
2508    #[serde(skip_serializing_if = "Option::is_none")]
2509    pub update_available: Option<bool>,
2510}
2511
2512#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2513pub struct DescribeWorkspaceSnapshotsRequest {
2514    #[serde(rename = "WorkspaceId")]
2515    #[serde(default)]
2516    pub workspace_id: String,
2517}
2518
2519#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2520pub struct DescribeWorkspaceSnapshotsResult {
2521    #[serde(rename = "RebuildSnapshots")]
2522    #[serde(default)]
2523    #[serde(skip_serializing_if = "Option::is_none")]
2524    pub rebuild_snapshots: Option<Vec<Snapshot>>,
2525    #[serde(rename = "RestoreSnapshots")]
2526    #[serde(default)]
2527    #[serde(skip_serializing_if = "Option::is_none")]
2528    pub restore_snapshots: Option<Vec<Snapshot>>,
2529}
2530
2531#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2532pub struct Snapshot {
2533    #[serde(rename = "SnapshotTime")]
2534    #[serde(default)]
2535    #[serde(skip_serializing_if = "Option::is_none")]
2536    pub snapshot_time: Option<f64>,
2537}
2538
2539#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2540pub struct DescribeWorkspacesConnectionStatusRequest {
2541    #[serde(rename = "NextToken")]
2542    #[serde(default)]
2543    #[serde(skip_serializing_if = "Option::is_none")]
2544    pub next_token: Option<String>,
2545    #[serde(rename = "WorkspaceIds")]
2546    #[serde(default)]
2547    #[serde(skip_serializing_if = "Option::is_none")]
2548    pub workspace_ids: Option<Vec<String>>,
2549}
2550
2551#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2552pub struct DescribeWorkspacesConnectionStatusResult {
2553    #[serde(rename = "NextToken")]
2554    #[serde(default)]
2555    #[serde(skip_serializing_if = "Option::is_none")]
2556    pub next_token: Option<String>,
2557    #[serde(rename = "WorkspacesConnectionStatus")]
2558    #[serde(default)]
2559    #[serde(skip_serializing_if = "Option::is_none")]
2560    pub workspaces_connection_status: Option<Vec<WorkspaceConnectionStatus>>,
2561}
2562
2563#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2564pub struct WorkspaceConnectionStatus {
2565    #[serde(rename = "ConnectionState")]
2566    #[serde(default)]
2567    #[serde(skip_serializing_if = "Option::is_none")]
2568    pub connection_state: Option<String>,
2569    #[serde(rename = "ConnectionStateCheckTimestamp")]
2570    #[serde(default)]
2571    #[serde(skip_serializing_if = "Option::is_none")]
2572    pub connection_state_check_timestamp: Option<f64>,
2573    #[serde(rename = "LastKnownUserConnectionTimestamp")]
2574    #[serde(default)]
2575    #[serde(skip_serializing_if = "Option::is_none")]
2576    pub last_known_user_connection_timestamp: Option<f64>,
2577    #[serde(rename = "WorkspaceId")]
2578    #[serde(default)]
2579    #[serde(skip_serializing_if = "Option::is_none")]
2580    pub workspace_id: Option<String>,
2581}
2582
2583#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2584pub struct DescribeWorkspacesPoolSessionsRequest {
2585    #[serde(rename = "Limit")]
2586    #[serde(default)]
2587    #[serde(skip_serializing_if = "Option::is_none")]
2588    pub limit: Option<i32>,
2589    #[serde(rename = "NextToken")]
2590    #[serde(default)]
2591    #[serde(skip_serializing_if = "Option::is_none")]
2592    pub next_token: Option<String>,
2593    #[serde(rename = "PoolId")]
2594    #[serde(default)]
2595    pub pool_id: String,
2596    #[serde(rename = "UserId")]
2597    #[serde(default)]
2598    #[serde(skip_serializing_if = "Option::is_none")]
2599    pub user_id: Option<String>,
2600}
2601
2602#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2603pub struct DescribeWorkspacesPoolSessionsResult {
2604    #[serde(rename = "NextToken")]
2605    #[serde(default)]
2606    #[serde(skip_serializing_if = "Option::is_none")]
2607    pub next_token: Option<String>,
2608    #[serde(rename = "Sessions")]
2609    #[serde(default)]
2610    #[serde(skip_serializing_if = "Option::is_none")]
2611    pub sessions: Option<Vec<WorkspacesPoolSession>>,
2612}
2613
2614#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2615pub struct WorkspacesPoolSession {
2616    #[serde(rename = "AuthenticationType")]
2617    #[serde(default)]
2618    #[serde(skip_serializing_if = "Option::is_none")]
2619    pub authentication_type: Option<String>,
2620    #[serde(rename = "ConnectionState")]
2621    #[serde(default)]
2622    #[serde(skip_serializing_if = "Option::is_none")]
2623    pub connection_state: Option<String>,
2624    #[serde(rename = "ExpirationTime")]
2625    #[serde(default)]
2626    #[serde(skip_serializing_if = "Option::is_none")]
2627    pub expiration_time: Option<f64>,
2628    #[serde(rename = "InstanceId")]
2629    #[serde(default)]
2630    #[serde(skip_serializing_if = "Option::is_none")]
2631    pub instance_id: Option<String>,
2632    #[serde(rename = "NetworkAccessConfiguration")]
2633    #[serde(default)]
2634    #[serde(skip_serializing_if = "Option::is_none")]
2635    pub network_access_configuration: Option<NetworkAccessConfiguration>,
2636    #[serde(rename = "PoolId")]
2637    #[serde(default)]
2638    #[serde(skip_serializing_if = "Option::is_none")]
2639    pub pool_id: Option<String>,
2640    #[serde(rename = "SessionId")]
2641    #[serde(default)]
2642    #[serde(skip_serializing_if = "Option::is_none")]
2643    pub session_id: Option<String>,
2644    #[serde(rename = "StartTime")]
2645    #[serde(default)]
2646    #[serde(skip_serializing_if = "Option::is_none")]
2647    pub start_time: Option<f64>,
2648    #[serde(rename = "UserId")]
2649    #[serde(default)]
2650    #[serde(skip_serializing_if = "Option::is_none")]
2651    pub user_id: Option<String>,
2652}
2653
2654#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2655pub struct NetworkAccessConfiguration {
2656    #[serde(rename = "EniId")]
2657    #[serde(default)]
2658    #[serde(skip_serializing_if = "Option::is_none")]
2659    pub eni_id: Option<String>,
2660    #[serde(rename = "EniPrivateIpAddress")]
2661    #[serde(default)]
2662    #[serde(skip_serializing_if = "Option::is_none")]
2663    pub eni_private_ip_address: Option<String>,
2664}
2665
2666#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2667pub struct DescribeWorkspacesPoolsRequest {
2668    #[serde(rename = "Filters")]
2669    #[serde(default)]
2670    #[serde(skip_serializing_if = "Option::is_none")]
2671    pub filters: Option<Vec<DescribeWorkspacesPoolsFilter>>,
2672    #[serde(rename = "Limit")]
2673    #[serde(default)]
2674    #[serde(skip_serializing_if = "Option::is_none")]
2675    pub limit: Option<i32>,
2676    #[serde(rename = "NextToken")]
2677    #[serde(default)]
2678    #[serde(skip_serializing_if = "Option::is_none")]
2679    pub next_token: Option<String>,
2680    #[serde(rename = "PoolIds")]
2681    #[serde(default)]
2682    #[serde(skip_serializing_if = "Option::is_none")]
2683    pub pool_ids: Option<Vec<String>>,
2684}
2685
2686#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2687pub struct DescribeWorkspacesPoolsFilter {
2688    #[serde(rename = "Name")]
2689    #[serde(default)]
2690    pub name: String,
2691    #[serde(rename = "Operator")]
2692    #[serde(default)]
2693    pub operator: String,
2694    #[serde(rename = "Values")]
2695    #[serde(default)]
2696    pub values: Vec<String>,
2697}
2698
2699#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2700pub struct DescribeWorkspacesPoolsResult {
2701    #[serde(rename = "NextToken")]
2702    #[serde(default)]
2703    #[serde(skip_serializing_if = "Option::is_none")]
2704    pub next_token: Option<String>,
2705    #[serde(rename = "WorkspacesPools")]
2706    #[serde(default)]
2707    #[serde(skip_serializing_if = "Option::is_none")]
2708    pub workspaces_pools: Option<Vec<WorkspacesPool>>,
2709}
2710
2711#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2712pub struct DescribeWorkspacesRequest {
2713    #[serde(rename = "BundleId")]
2714    #[serde(default)]
2715    #[serde(skip_serializing_if = "Option::is_none")]
2716    pub bundle_id: Option<String>,
2717    #[serde(rename = "DirectoryId")]
2718    #[serde(default)]
2719    #[serde(skip_serializing_if = "Option::is_none")]
2720    pub directory_id: Option<String>,
2721    #[serde(rename = "Limit")]
2722    #[serde(default)]
2723    #[serde(skip_serializing_if = "Option::is_none")]
2724    pub limit: Option<i32>,
2725    #[serde(rename = "NextToken")]
2726    #[serde(default)]
2727    #[serde(skip_serializing_if = "Option::is_none")]
2728    pub next_token: Option<String>,
2729    #[serde(rename = "UserName")]
2730    #[serde(default)]
2731    #[serde(skip_serializing_if = "Option::is_none")]
2732    pub user_name: Option<String>,
2733    #[serde(rename = "WorkspaceIds")]
2734    #[serde(default)]
2735    #[serde(skip_serializing_if = "Option::is_none")]
2736    pub workspace_ids: Option<Vec<String>>,
2737    #[serde(rename = "WorkspaceName")]
2738    #[serde(default)]
2739    #[serde(skip_serializing_if = "Option::is_none")]
2740    pub workspace_name: Option<String>,
2741}
2742
2743#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2744pub struct DescribeWorkspacesResult {
2745    #[serde(rename = "NextToken")]
2746    #[serde(default)]
2747    #[serde(skip_serializing_if = "Option::is_none")]
2748    pub next_token: Option<String>,
2749    #[serde(rename = "Workspaces")]
2750    #[serde(default)]
2751    #[serde(skip_serializing_if = "Option::is_none")]
2752    pub workspaces: Option<Vec<Workspace>>,
2753}
2754
2755#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2756pub struct DisassociateConnectionAliasRequest {
2757    #[serde(rename = "AliasId")]
2758    #[serde(default)]
2759    pub alias_id: String,
2760}
2761
2762#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2763pub struct DisassociateConnectionAliasResult {}
2764
2765#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2766pub struct DisassociateIpGroupsRequest {
2767    #[serde(rename = "DirectoryId")]
2768    #[serde(default)]
2769    pub directory_id: String,
2770    #[serde(rename = "GroupIds")]
2771    #[serde(default)]
2772    pub group_ids: Vec<String>,
2773}
2774
2775#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2776pub struct DisassociateIpGroupsResult {}
2777
2778#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2779pub struct DisassociateWorkspaceApplicationRequest {
2780    #[serde(rename = "ApplicationId")]
2781    #[serde(default)]
2782    pub application_id: String,
2783    #[serde(rename = "WorkspaceId")]
2784    #[serde(default)]
2785    pub workspace_id: String,
2786}
2787
2788#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2789pub struct DisassociateWorkspaceApplicationResult {
2790    #[serde(rename = "Association")]
2791    #[serde(default)]
2792    #[serde(skip_serializing_if = "Option::is_none")]
2793    pub association: Option<WorkspaceResourceAssociation>,
2794}
2795
2796#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2797pub struct GetAccountLinkRequest {
2798    #[serde(rename = "LinkId")]
2799    #[serde(default)]
2800    #[serde(skip_serializing_if = "Option::is_none")]
2801    pub link_id: Option<String>,
2802    #[serde(rename = "LinkedAccountId")]
2803    #[serde(default)]
2804    #[serde(skip_serializing_if = "Option::is_none")]
2805    pub linked_account_id: Option<String>,
2806}
2807
2808#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2809pub struct GetAccountLinkResult {
2810    #[serde(rename = "AccountLink")]
2811    #[serde(default)]
2812    #[serde(skip_serializing_if = "Option::is_none")]
2813    pub account_link: Option<AccountLink>,
2814}
2815
2816#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2817pub struct ImportClientBrandingRequest {
2818    #[serde(rename = "DeviceTypeAndroid")]
2819    #[serde(default)]
2820    #[serde(skip_serializing_if = "Option::is_none")]
2821    pub device_type_android: Option<DefaultImportClientBrandingAttributes>,
2822    #[serde(rename = "DeviceTypeIos")]
2823    #[serde(default)]
2824    #[serde(skip_serializing_if = "Option::is_none")]
2825    pub device_type_ios: Option<IosImportClientBrandingAttributes>,
2826    #[serde(rename = "DeviceTypeLinux")]
2827    #[serde(default)]
2828    #[serde(skip_serializing_if = "Option::is_none")]
2829    pub device_type_linux: Option<DefaultImportClientBrandingAttributes>,
2830    #[serde(rename = "DeviceTypeOsx")]
2831    #[serde(default)]
2832    #[serde(skip_serializing_if = "Option::is_none")]
2833    pub device_type_osx: Option<DefaultImportClientBrandingAttributes>,
2834    #[serde(rename = "DeviceTypeWeb")]
2835    #[serde(default)]
2836    #[serde(skip_serializing_if = "Option::is_none")]
2837    pub device_type_web: Option<DefaultImportClientBrandingAttributes>,
2838    #[serde(rename = "DeviceTypeWindows")]
2839    #[serde(default)]
2840    #[serde(skip_serializing_if = "Option::is_none")]
2841    pub device_type_windows: Option<DefaultImportClientBrandingAttributes>,
2842    #[serde(rename = "ResourceId")]
2843    #[serde(default)]
2844    pub resource_id: String,
2845}
2846
2847#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2848pub struct DefaultImportClientBrandingAttributes {
2849    #[serde(rename = "ForgotPasswordLink")]
2850    #[serde(default)]
2851    #[serde(skip_serializing_if = "Option::is_none")]
2852    pub forgot_password_link: Option<String>,
2853    #[serde(rename = "LoginMessage")]
2854    #[serde(default)]
2855    #[serde(skip_serializing_if = "Option::is_none")]
2856    pub login_message: Option<std::collections::HashMap<String, String>>,
2857    #[serde(rename = "Logo")]
2858    #[serde(default)]
2859    #[serde(skip_serializing_if = "Option::is_none")]
2860    pub logo: Option<String>,
2861    #[serde(rename = "SupportEmail")]
2862    #[serde(default)]
2863    #[serde(skip_serializing_if = "Option::is_none")]
2864    pub support_email: Option<String>,
2865    #[serde(rename = "SupportLink")]
2866    #[serde(default)]
2867    #[serde(skip_serializing_if = "Option::is_none")]
2868    pub support_link: Option<String>,
2869}
2870
2871#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2872pub struct IosImportClientBrandingAttributes {
2873    #[serde(rename = "ForgotPasswordLink")]
2874    #[serde(default)]
2875    #[serde(skip_serializing_if = "Option::is_none")]
2876    pub forgot_password_link: Option<String>,
2877    #[serde(rename = "LoginMessage")]
2878    #[serde(default)]
2879    #[serde(skip_serializing_if = "Option::is_none")]
2880    pub login_message: Option<std::collections::HashMap<String, String>>,
2881    #[serde(rename = "Logo")]
2882    #[serde(default)]
2883    #[serde(skip_serializing_if = "Option::is_none")]
2884    pub logo: Option<String>,
2885    #[serde(rename = "Logo2x")]
2886    #[serde(default)]
2887    #[serde(skip_serializing_if = "Option::is_none")]
2888    pub logo2x: Option<String>,
2889    #[serde(rename = "Logo3x")]
2890    #[serde(default)]
2891    #[serde(skip_serializing_if = "Option::is_none")]
2892    pub logo3x: Option<String>,
2893    #[serde(rename = "SupportEmail")]
2894    #[serde(default)]
2895    #[serde(skip_serializing_if = "Option::is_none")]
2896    pub support_email: Option<String>,
2897    #[serde(rename = "SupportLink")]
2898    #[serde(default)]
2899    #[serde(skip_serializing_if = "Option::is_none")]
2900    pub support_link: Option<String>,
2901}
2902
2903#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2904pub struct ImportClientBrandingResult {
2905    #[serde(rename = "DeviceTypeAndroid")]
2906    #[serde(default)]
2907    #[serde(skip_serializing_if = "Option::is_none")]
2908    pub device_type_android: Option<DefaultClientBrandingAttributes>,
2909    #[serde(rename = "DeviceTypeIos")]
2910    #[serde(default)]
2911    #[serde(skip_serializing_if = "Option::is_none")]
2912    pub device_type_ios: Option<IosClientBrandingAttributes>,
2913    #[serde(rename = "DeviceTypeLinux")]
2914    #[serde(default)]
2915    #[serde(skip_serializing_if = "Option::is_none")]
2916    pub device_type_linux: Option<DefaultClientBrandingAttributes>,
2917    #[serde(rename = "DeviceTypeOsx")]
2918    #[serde(default)]
2919    #[serde(skip_serializing_if = "Option::is_none")]
2920    pub device_type_osx: Option<DefaultClientBrandingAttributes>,
2921    #[serde(rename = "DeviceTypeWeb")]
2922    #[serde(default)]
2923    #[serde(skip_serializing_if = "Option::is_none")]
2924    pub device_type_web: Option<DefaultClientBrandingAttributes>,
2925    #[serde(rename = "DeviceTypeWindows")]
2926    #[serde(default)]
2927    #[serde(skip_serializing_if = "Option::is_none")]
2928    pub device_type_windows: Option<DefaultClientBrandingAttributes>,
2929}
2930
2931#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2932pub struct ImportCustomWorkspaceImageRequest {
2933    #[serde(rename = "ComputeType")]
2934    #[serde(default)]
2935    pub compute_type: String,
2936    #[serde(rename = "ImageDescription")]
2937    #[serde(default)]
2938    pub image_description: String,
2939    #[serde(rename = "ImageName")]
2940    #[serde(default)]
2941    pub image_name: String,
2942    #[serde(rename = "ImageSource")]
2943    #[serde(default)]
2944    pub image_source: ImageSourceIdentifier,
2945    #[serde(rename = "InfrastructureConfigurationArn")]
2946    #[serde(default)]
2947    pub infrastructure_configuration_arn: String,
2948    #[serde(rename = "OsVersion")]
2949    #[serde(default)]
2950    pub os_version: String,
2951    #[serde(rename = "Platform")]
2952    #[serde(default)]
2953    pub platform: String,
2954    #[serde(rename = "Protocol")]
2955    #[serde(default)]
2956    pub protocol: String,
2957    #[serde(rename = "Tags")]
2958    #[serde(default)]
2959    #[serde(skip_serializing_if = "Option::is_none")]
2960    pub tags: Option<Vec<Tag>>,
2961}
2962
2963#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2964pub struct ImportCustomWorkspaceImageResult {
2965    #[serde(rename = "ImageId")]
2966    #[serde(default)]
2967    #[serde(skip_serializing_if = "Option::is_none")]
2968    pub image_id: Option<String>,
2969    #[serde(rename = "State")]
2970    #[serde(default)]
2971    #[serde(skip_serializing_if = "Option::is_none")]
2972    pub state: Option<String>,
2973}
2974
2975#[derive(Debug, Clone, Default, Deserialize, Serialize)]
2976pub struct ImportWorkspaceImageRequest {
2977    #[serde(rename = "Applications")]
2978    #[serde(default)]
2979    #[serde(skip_serializing_if = "Option::is_none")]
2980    pub applications: Option<Vec<String>>,
2981    #[serde(rename = "Ec2ImageId")]
2982    #[serde(default)]
2983    pub ec2_image_id: String,
2984    #[serde(rename = "ImageDescription")]
2985    #[serde(default)]
2986    pub image_description: String,
2987    #[serde(rename = "ImageName")]
2988    #[serde(default)]
2989    pub image_name: String,
2990    #[serde(rename = "IngestionProcess")]
2991    #[serde(default)]
2992    pub ingestion_process: String,
2993    #[serde(rename = "Tags")]
2994    #[serde(default)]
2995    #[serde(skip_serializing_if = "Option::is_none")]
2996    pub tags: Option<Vec<Tag>>,
2997}
2998
2999#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3000pub struct ImportWorkspaceImageResult {
3001    #[serde(rename = "ImageId")]
3002    #[serde(default)]
3003    #[serde(skip_serializing_if = "Option::is_none")]
3004    pub image_id: Option<String>,
3005}
3006
3007#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3008pub struct ListAccountLinksRequest {
3009    #[serde(rename = "LinkStatusFilter")]
3010    #[serde(default)]
3011    #[serde(skip_serializing_if = "Option::is_none")]
3012    pub link_status_filter: Option<Vec<String>>,
3013    #[serde(rename = "MaxResults")]
3014    #[serde(default)]
3015    #[serde(skip_serializing_if = "Option::is_none")]
3016    pub max_results: Option<i32>,
3017    #[serde(rename = "NextToken")]
3018    #[serde(default)]
3019    #[serde(skip_serializing_if = "Option::is_none")]
3020    pub next_token: Option<String>,
3021}
3022
3023#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3024pub struct ListAccountLinksResult {
3025    #[serde(rename = "AccountLinks")]
3026    #[serde(default)]
3027    #[serde(skip_serializing_if = "Option::is_none")]
3028    pub account_links: Option<Vec<AccountLink>>,
3029    #[serde(rename = "NextToken")]
3030    #[serde(default)]
3031    #[serde(skip_serializing_if = "Option::is_none")]
3032    pub next_token: Option<String>,
3033}
3034
3035#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3036pub struct ListAvailableManagementCidrRangesRequest {
3037    #[serde(rename = "ManagementCidrRangeConstraint")]
3038    #[serde(default)]
3039    pub management_cidr_range_constraint: String,
3040    #[serde(rename = "MaxResults")]
3041    #[serde(default)]
3042    #[serde(skip_serializing_if = "Option::is_none")]
3043    pub max_results: Option<i32>,
3044    #[serde(rename = "NextToken")]
3045    #[serde(default)]
3046    #[serde(skip_serializing_if = "Option::is_none")]
3047    pub next_token: Option<String>,
3048}
3049
3050#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3051pub struct ListAvailableManagementCidrRangesResult {
3052    #[serde(rename = "ManagementCidrRanges")]
3053    #[serde(default)]
3054    #[serde(skip_serializing_if = "Option::is_none")]
3055    pub management_cidr_ranges: Option<Vec<String>>,
3056    #[serde(rename = "NextToken")]
3057    #[serde(default)]
3058    #[serde(skip_serializing_if = "Option::is_none")]
3059    pub next_token: Option<String>,
3060}
3061
3062#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3063pub struct MigrateWorkspaceRequest {
3064    #[serde(rename = "BundleId")]
3065    #[serde(default)]
3066    pub bundle_id: String,
3067    #[serde(rename = "SourceWorkspaceId")]
3068    #[serde(default)]
3069    pub source_workspace_id: String,
3070}
3071
3072#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3073pub struct MigrateWorkspaceResult {
3074    #[serde(rename = "SourceWorkspaceId")]
3075    #[serde(default)]
3076    #[serde(skip_serializing_if = "Option::is_none")]
3077    pub source_workspace_id: Option<String>,
3078    #[serde(rename = "TargetWorkspaceId")]
3079    #[serde(default)]
3080    #[serde(skip_serializing_if = "Option::is_none")]
3081    pub target_workspace_id: Option<String>,
3082}
3083
3084#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3085pub struct ModifyAccountRequest {
3086    #[serde(rename = "DedicatedTenancyManagementCidrRange")]
3087    #[serde(default)]
3088    #[serde(skip_serializing_if = "Option::is_none")]
3089    pub dedicated_tenancy_management_cidr_range: Option<String>,
3090    #[serde(rename = "DedicatedTenancySupport")]
3091    #[serde(default)]
3092    #[serde(skip_serializing_if = "Option::is_none")]
3093    pub dedicated_tenancy_support: Option<String>,
3094}
3095
3096#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3097pub struct ModifyAccountResult {
3098    #[serde(rename = "Message")]
3099    #[serde(default)]
3100    #[serde(skip_serializing_if = "Option::is_none")]
3101    pub message: Option<String>,
3102}
3103
3104#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3105pub struct ModifyCertificateBasedAuthPropertiesRequest {
3106    #[serde(rename = "CertificateBasedAuthProperties")]
3107    #[serde(default)]
3108    #[serde(skip_serializing_if = "Option::is_none")]
3109    pub certificate_based_auth_properties: Option<CertificateBasedAuthProperties>,
3110    #[serde(rename = "PropertiesToDelete")]
3111    #[serde(default)]
3112    #[serde(skip_serializing_if = "Option::is_none")]
3113    pub properties_to_delete: Option<Vec<String>>,
3114    #[serde(rename = "ResourceId")]
3115    #[serde(default)]
3116    pub resource_id: String,
3117}
3118
3119#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3120pub struct ModifyCertificateBasedAuthPropertiesResult {}
3121
3122#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3123pub struct ModifyClientPropertiesRequest {
3124    #[serde(rename = "ClientProperties")]
3125    #[serde(default)]
3126    pub client_properties: ClientProperties,
3127    #[serde(rename = "ResourceId")]
3128    #[serde(default)]
3129    pub resource_id: String,
3130}
3131
3132#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3133pub struct ModifyClientPropertiesResult {}
3134
3135#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3136pub struct ModifyEndpointEncryptionModeRequest {
3137    #[serde(rename = "DirectoryId")]
3138    #[serde(default)]
3139    pub directory_id: String,
3140    #[serde(rename = "EndpointEncryptionMode")]
3141    #[serde(default)]
3142    pub endpoint_encryption_mode: String,
3143}
3144
3145#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3146pub struct ModifyEndpointEncryptionModeResponse {}
3147
3148#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3149pub struct ModifySamlPropertiesRequest {
3150    #[serde(rename = "PropertiesToDelete")]
3151    #[serde(default)]
3152    #[serde(skip_serializing_if = "Option::is_none")]
3153    pub properties_to_delete: Option<Vec<String>>,
3154    #[serde(rename = "ResourceId")]
3155    #[serde(default)]
3156    pub resource_id: String,
3157    #[serde(rename = "SamlProperties")]
3158    #[serde(default)]
3159    #[serde(skip_serializing_if = "Option::is_none")]
3160    pub saml_properties: Option<SamlProperties>,
3161}
3162
3163#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3164pub struct ModifySamlPropertiesResult {}
3165
3166#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3167pub struct ModifySelfservicePermissionsRequest {
3168    #[serde(rename = "ResourceId")]
3169    #[serde(default)]
3170    pub resource_id: String,
3171    #[serde(rename = "SelfservicePermissions")]
3172    #[serde(default)]
3173    pub selfservice_permissions: SelfservicePermissions,
3174}
3175
3176#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3177pub struct ModifySelfservicePermissionsResult {}
3178
3179#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3180pub struct ModifyStreamingPropertiesRequest {
3181    #[serde(rename = "ResourceId")]
3182    #[serde(default)]
3183    pub resource_id: String,
3184    #[serde(rename = "StreamingProperties")]
3185    #[serde(default)]
3186    #[serde(skip_serializing_if = "Option::is_none")]
3187    pub streaming_properties: Option<StreamingProperties>,
3188}
3189
3190#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3191pub struct ModifyStreamingPropertiesResult {}
3192
3193#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3194pub struct ModifyWorkspaceAccessPropertiesRequest {
3195    #[serde(rename = "ResourceId")]
3196    #[serde(default)]
3197    pub resource_id: String,
3198    #[serde(rename = "WorkspaceAccessProperties")]
3199    #[serde(default)]
3200    pub workspace_access_properties: WorkspaceAccessProperties,
3201}
3202
3203#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3204pub struct ModifyWorkspaceAccessPropertiesResult {}
3205
3206#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3207pub struct ModifyWorkspaceCreationPropertiesRequest {
3208    #[serde(rename = "ResourceId")]
3209    #[serde(default)]
3210    pub resource_id: String,
3211    #[serde(rename = "WorkspaceCreationProperties")]
3212    #[serde(default)]
3213    pub workspace_creation_properties: WorkspaceCreationProperties,
3214}
3215
3216#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3217pub struct WorkspaceCreationProperties {
3218    #[serde(rename = "CustomSecurityGroupId")]
3219    #[serde(default)]
3220    #[serde(skip_serializing_if = "Option::is_none")]
3221    pub custom_security_group_id: Option<String>,
3222    #[serde(rename = "DefaultOu")]
3223    #[serde(default)]
3224    #[serde(skip_serializing_if = "Option::is_none")]
3225    pub default_ou: Option<String>,
3226    #[serde(rename = "EnableInternetAccess")]
3227    #[serde(default)]
3228    #[serde(skip_serializing_if = "Option::is_none")]
3229    pub enable_internet_access: Option<bool>,
3230    #[serde(rename = "EnableMaintenanceMode")]
3231    #[serde(default)]
3232    #[serde(skip_serializing_if = "Option::is_none")]
3233    pub enable_maintenance_mode: Option<bool>,
3234    #[serde(rename = "InstanceIamRoleArn")]
3235    #[serde(default)]
3236    #[serde(skip_serializing_if = "Option::is_none")]
3237    pub instance_iam_role_arn: Option<String>,
3238    #[serde(rename = "UserEnabledAsLocalAdministrator")]
3239    #[serde(default)]
3240    #[serde(skip_serializing_if = "Option::is_none")]
3241    pub user_enabled_as_local_administrator: Option<bool>,
3242}
3243
3244#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3245pub struct ModifyWorkspaceCreationPropertiesResult {}
3246
3247#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3248pub struct ModifyWorkspacePropertiesRequest {
3249    #[serde(rename = "DataReplication")]
3250    #[serde(default)]
3251    #[serde(skip_serializing_if = "Option::is_none")]
3252    pub data_replication: Option<String>,
3253    #[serde(rename = "WorkspaceId")]
3254    #[serde(default)]
3255    pub workspace_id: String,
3256    #[serde(rename = "WorkspaceProperties")]
3257    #[serde(default)]
3258    #[serde(skip_serializing_if = "Option::is_none")]
3259    pub workspace_properties: Option<WorkspaceProperties>,
3260}
3261
3262#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3263pub struct ModifyWorkspacePropertiesResult {}
3264
3265#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3266pub struct ModifyWorkspaceStateRequest {
3267    #[serde(rename = "WorkspaceId")]
3268    #[serde(default)]
3269    pub workspace_id: String,
3270    #[serde(rename = "WorkspaceState")]
3271    #[serde(default)]
3272    pub workspace_state: String,
3273}
3274
3275#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3276pub struct ModifyWorkspaceStateResult {}
3277
3278#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3279pub struct RebootWorkspacesRequest {
3280    #[serde(rename = "RebootWorkspaceRequests")]
3281    #[serde(default)]
3282    pub reboot_workspace_requests: Vec<RebootRequest>,
3283}
3284
3285#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3286pub struct RebootRequest {
3287    #[serde(rename = "WorkspaceId")]
3288    #[serde(default)]
3289    pub workspace_id: String,
3290}
3291
3292#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3293pub struct RebootWorkspacesResult {
3294    #[serde(rename = "FailedRequests")]
3295    #[serde(default)]
3296    #[serde(skip_serializing_if = "Option::is_none")]
3297    pub failed_requests: Option<Vec<FailedWorkspaceChangeRequest>>,
3298}
3299
3300#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3301pub struct FailedWorkspaceChangeRequest {
3302    #[serde(rename = "ErrorCode")]
3303    #[serde(default)]
3304    #[serde(skip_serializing_if = "Option::is_none")]
3305    pub error_code: Option<String>,
3306    #[serde(rename = "ErrorMessage")]
3307    #[serde(default)]
3308    #[serde(skip_serializing_if = "Option::is_none")]
3309    pub error_message: Option<String>,
3310    #[serde(rename = "WorkspaceId")]
3311    #[serde(default)]
3312    #[serde(skip_serializing_if = "Option::is_none")]
3313    pub workspace_id: Option<String>,
3314}
3315
3316#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3317pub struct RebuildWorkspacesRequest {
3318    #[serde(rename = "RebuildWorkspaceRequests")]
3319    #[serde(default)]
3320    pub rebuild_workspace_requests: Vec<RebuildRequest>,
3321}
3322
3323#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3324pub struct RebuildRequest {
3325    #[serde(rename = "WorkspaceId")]
3326    #[serde(default)]
3327    pub workspace_id: String,
3328}
3329
3330#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3331pub struct RebuildWorkspacesResult {
3332    #[serde(rename = "FailedRequests")]
3333    #[serde(default)]
3334    #[serde(skip_serializing_if = "Option::is_none")]
3335    pub failed_requests: Option<Vec<FailedWorkspaceChangeRequest>>,
3336}
3337
3338#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3339pub struct RegisterWorkspaceDirectoryRequest {
3340    #[serde(rename = "ActiveDirectoryConfig")]
3341    #[serde(default)]
3342    #[serde(skip_serializing_if = "Option::is_none")]
3343    pub active_directory_config: Option<ActiveDirectoryConfig>,
3344    #[serde(rename = "DirectoryId")]
3345    #[serde(default)]
3346    #[serde(skip_serializing_if = "Option::is_none")]
3347    pub directory_id: Option<String>,
3348    #[serde(rename = "EnableSelfService")]
3349    #[serde(default)]
3350    #[serde(skip_serializing_if = "Option::is_none")]
3351    pub enable_self_service: Option<bool>,
3352    #[serde(rename = "IdcInstanceArn")]
3353    #[serde(default)]
3354    #[serde(skip_serializing_if = "Option::is_none")]
3355    pub idc_instance_arn: Option<String>,
3356    #[serde(rename = "MicrosoftEntraConfig")]
3357    #[serde(default)]
3358    #[serde(skip_serializing_if = "Option::is_none")]
3359    pub microsoft_entra_config: Option<MicrosoftEntraConfig>,
3360    #[serde(rename = "SubnetIds")]
3361    #[serde(default)]
3362    #[serde(skip_serializing_if = "Option::is_none")]
3363    pub subnet_ids: Option<Vec<String>>,
3364    #[serde(rename = "Tags")]
3365    #[serde(default)]
3366    #[serde(skip_serializing_if = "Option::is_none")]
3367    pub tags: Option<Vec<Tag>>,
3368    #[serde(rename = "Tenancy")]
3369    #[serde(default)]
3370    #[serde(skip_serializing_if = "Option::is_none")]
3371    pub tenancy: Option<String>,
3372    #[serde(rename = "UserIdentityType")]
3373    #[serde(default)]
3374    #[serde(skip_serializing_if = "Option::is_none")]
3375    pub user_identity_type: Option<String>,
3376    #[serde(rename = "WorkspaceDirectoryDescription")]
3377    #[serde(default)]
3378    #[serde(skip_serializing_if = "Option::is_none")]
3379    pub workspace_directory_description: Option<String>,
3380    #[serde(rename = "WorkspaceDirectoryName")]
3381    #[serde(default)]
3382    #[serde(skip_serializing_if = "Option::is_none")]
3383    pub workspace_directory_name: Option<String>,
3384    #[serde(rename = "WorkspaceType")]
3385    #[serde(default)]
3386    #[serde(skip_serializing_if = "Option::is_none")]
3387    pub workspace_type: Option<String>,
3388}
3389
3390#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3391pub struct RegisterWorkspaceDirectoryResult {
3392    #[serde(rename = "DirectoryId")]
3393    #[serde(default)]
3394    #[serde(skip_serializing_if = "Option::is_none")]
3395    pub directory_id: Option<String>,
3396    #[serde(rename = "State")]
3397    #[serde(default)]
3398    #[serde(skip_serializing_if = "Option::is_none")]
3399    pub state: Option<String>,
3400}
3401
3402#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3403pub struct RejectAccountLinkInvitationRequest {
3404    #[serde(rename = "ClientToken")]
3405    #[serde(default)]
3406    #[serde(skip_serializing_if = "Option::is_none")]
3407    pub client_token: Option<String>,
3408    #[serde(rename = "LinkId")]
3409    #[serde(default)]
3410    pub link_id: String,
3411}
3412
3413#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3414pub struct RejectAccountLinkInvitationResult {
3415    #[serde(rename = "AccountLink")]
3416    #[serde(default)]
3417    #[serde(skip_serializing_if = "Option::is_none")]
3418    pub account_link: Option<AccountLink>,
3419}
3420
3421#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3422pub struct RestoreWorkspaceRequest {
3423    #[serde(rename = "WorkspaceId")]
3424    #[serde(default)]
3425    pub workspace_id: String,
3426}
3427
3428#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3429pub struct RestoreWorkspaceResult {}
3430
3431#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3432pub struct RevokeIpRulesRequest {
3433    #[serde(rename = "GroupId")]
3434    #[serde(default)]
3435    pub group_id: String,
3436    #[serde(rename = "UserRules")]
3437    #[serde(default)]
3438    pub user_rules: Vec<String>,
3439}
3440
3441#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3442pub struct RevokeIpRulesResult {}
3443
3444#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3445pub struct StartWorkspacesPoolRequest {
3446    #[serde(rename = "PoolId")]
3447    #[serde(default)]
3448    pub pool_id: String,
3449}
3450
3451#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3452pub struct StartWorkspacesPoolResult {}
3453
3454#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3455pub struct StartWorkspacesRequest {
3456    #[serde(rename = "StartWorkspaceRequests")]
3457    #[serde(default)]
3458    pub start_workspace_requests: Vec<StartRequest>,
3459}
3460
3461#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3462pub struct StartRequest {
3463    #[serde(rename = "WorkspaceId")]
3464    #[serde(default)]
3465    #[serde(skip_serializing_if = "Option::is_none")]
3466    pub workspace_id: Option<String>,
3467}
3468
3469#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3470pub struct StartWorkspacesResult {
3471    #[serde(rename = "FailedRequests")]
3472    #[serde(default)]
3473    #[serde(skip_serializing_if = "Option::is_none")]
3474    pub failed_requests: Option<Vec<FailedWorkspaceChangeRequest>>,
3475}
3476
3477#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3478pub struct StopWorkspacesPoolRequest {
3479    #[serde(rename = "PoolId")]
3480    #[serde(default)]
3481    pub pool_id: String,
3482}
3483
3484#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3485pub struct StopWorkspacesPoolResult {}
3486
3487#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3488pub struct StopWorkspacesRequest {
3489    #[serde(rename = "StopWorkspaceRequests")]
3490    #[serde(default)]
3491    pub stop_workspace_requests: Vec<StopRequest>,
3492}
3493
3494#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3495pub struct StopRequest {
3496    #[serde(rename = "WorkspaceId")]
3497    #[serde(default)]
3498    #[serde(skip_serializing_if = "Option::is_none")]
3499    pub workspace_id: Option<String>,
3500}
3501
3502#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3503pub struct StopWorkspacesResult {
3504    #[serde(rename = "FailedRequests")]
3505    #[serde(default)]
3506    #[serde(skip_serializing_if = "Option::is_none")]
3507    pub failed_requests: Option<Vec<FailedWorkspaceChangeRequest>>,
3508}
3509
3510#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3511pub struct TerminateWorkspacesPoolRequest {
3512    #[serde(rename = "PoolId")]
3513    #[serde(default)]
3514    pub pool_id: String,
3515}
3516
3517#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3518pub struct TerminateWorkspacesPoolResult {}
3519
3520#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3521pub struct TerminateWorkspacesPoolSessionRequest {
3522    #[serde(rename = "SessionId")]
3523    #[serde(default)]
3524    pub session_id: String,
3525}
3526
3527#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3528pub struct TerminateWorkspacesPoolSessionResult {}
3529
3530#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3531pub struct TerminateWorkspacesRequest {
3532    #[serde(rename = "TerminateWorkspaceRequests")]
3533    #[serde(default)]
3534    pub terminate_workspace_requests: Vec<TerminateRequest>,
3535}
3536
3537#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3538pub struct TerminateRequest {
3539    #[serde(rename = "WorkspaceId")]
3540    #[serde(default)]
3541    pub workspace_id: String,
3542}
3543
3544#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3545pub struct TerminateWorkspacesResult {
3546    #[serde(rename = "FailedRequests")]
3547    #[serde(default)]
3548    #[serde(skip_serializing_if = "Option::is_none")]
3549    pub failed_requests: Option<Vec<FailedWorkspaceChangeRequest>>,
3550}
3551
3552#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3553pub struct UpdateConnectClientAddInRequest {
3554    #[serde(rename = "AddInId")]
3555    #[serde(default)]
3556    pub add_in_id: String,
3557    #[serde(rename = "Name")]
3558    #[serde(default)]
3559    #[serde(skip_serializing_if = "Option::is_none")]
3560    pub name: Option<String>,
3561    #[serde(rename = "ResourceId")]
3562    #[serde(default)]
3563    pub resource_id: String,
3564    #[serde(rename = "URL")]
3565    #[serde(default)]
3566    #[serde(skip_serializing_if = "Option::is_none")]
3567    pub u_r_l: Option<String>,
3568}
3569
3570#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3571pub struct UpdateConnectClientAddInResult {}
3572
3573#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3574pub struct UpdateConnectionAliasPermissionRequest {
3575    #[serde(rename = "AliasId")]
3576    #[serde(default)]
3577    pub alias_id: String,
3578    #[serde(rename = "ConnectionAliasPermission")]
3579    #[serde(default)]
3580    pub connection_alias_permission: ConnectionAliasPermission,
3581}
3582
3583#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3584pub struct UpdateConnectionAliasPermissionResult {}
3585
3586#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3587pub struct UpdateRulesOfIpGroupRequest {
3588    #[serde(rename = "GroupId")]
3589    #[serde(default)]
3590    pub group_id: String,
3591    #[serde(rename = "UserRules")]
3592    #[serde(default)]
3593    pub user_rules: Vec<IpRuleItem>,
3594}
3595
3596#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3597pub struct UpdateRulesOfIpGroupResult {}
3598
3599#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3600pub struct UpdateWorkspaceBundleRequest {
3601    #[serde(rename = "BundleId")]
3602    #[serde(default)]
3603    #[serde(skip_serializing_if = "Option::is_none")]
3604    pub bundle_id: Option<String>,
3605    #[serde(rename = "ImageId")]
3606    #[serde(default)]
3607    #[serde(skip_serializing_if = "Option::is_none")]
3608    pub image_id: Option<String>,
3609}
3610
3611#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3612pub struct UpdateWorkspaceBundleResult {}
3613
3614#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3615pub struct UpdateWorkspaceImagePermissionRequest {
3616    #[serde(rename = "AllowCopyImage")]
3617    #[serde(default)]
3618    pub allow_copy_image: bool,
3619    #[serde(rename = "ImageId")]
3620    #[serde(default)]
3621    pub image_id: String,
3622    #[serde(rename = "SharedAccountId")]
3623    #[serde(default)]
3624    pub shared_account_id: String,
3625}
3626
3627#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3628pub struct UpdateWorkspaceImagePermissionResult {}
3629
3630#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3631pub struct UpdateWorkspacesPoolRequest {
3632    #[serde(rename = "ApplicationSettings")]
3633    #[serde(default)]
3634    #[serde(skip_serializing_if = "Option::is_none")]
3635    pub application_settings: Option<ApplicationSettingsRequest>,
3636    #[serde(rename = "BundleId")]
3637    #[serde(default)]
3638    #[serde(skip_serializing_if = "Option::is_none")]
3639    pub bundle_id: Option<String>,
3640    #[serde(rename = "Capacity")]
3641    #[serde(default)]
3642    #[serde(skip_serializing_if = "Option::is_none")]
3643    pub capacity: Option<Capacity>,
3644    #[serde(rename = "Description")]
3645    #[serde(default)]
3646    #[serde(skip_serializing_if = "Option::is_none")]
3647    pub description: Option<String>,
3648    #[serde(rename = "DirectoryId")]
3649    #[serde(default)]
3650    #[serde(skip_serializing_if = "Option::is_none")]
3651    pub directory_id: Option<String>,
3652    #[serde(rename = "PoolId")]
3653    #[serde(default)]
3654    pub pool_id: String,
3655    #[serde(rename = "RunningMode")]
3656    #[serde(default)]
3657    #[serde(skip_serializing_if = "Option::is_none")]
3658    pub running_mode: Option<String>,
3659    #[serde(rename = "TimeoutSettings")]
3660    #[serde(default)]
3661    #[serde(skip_serializing_if = "Option::is_none")]
3662    pub timeout_settings: Option<TimeoutSettings>,
3663}
3664
3665#[derive(Debug, Clone, Default, Deserialize, Serialize)]
3666pub struct UpdateWorkspacesPoolResult {
3667    #[serde(rename = "WorkspacesPool")]
3668    #[serde(default)]
3669    #[serde(skip_serializing_if = "Option::is_none")]
3670    pub workspaces_pool: Option<WorkspacesPool>,
3671}