1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package workspaces
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/workspaces/types"
10	smithy "github.com/aws/smithy-go"
11	"github.com/aws/smithy-go/encoding/httpbinding"
12	smithyjson "github.com/aws/smithy-go/encoding/json"
13	"github.com/aws/smithy-go/middleware"
14	smithyhttp "github.com/aws/smithy-go/transport/http"
15)
16
17type awsAwsjson11_serializeOpAssociateConnectionAlias struct {
18}
19
20func (*awsAwsjson11_serializeOpAssociateConnectionAlias) ID() string {
21	return "OperationSerializer"
22}
23
24func (m *awsAwsjson11_serializeOpAssociateConnectionAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
25	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
26) {
27	request, ok := in.Request.(*smithyhttp.Request)
28	if !ok {
29		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
30	}
31
32	input, ok := in.Parameters.(*AssociateConnectionAliasInput)
33	_ = input
34	if !ok {
35		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
36	}
37
38	request.Request.URL.Path = "/"
39	request.Request.Method = "POST"
40	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
41	if err != nil {
42		return out, metadata, &smithy.SerializationError{Err: err}
43	}
44	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
45	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.AssociateConnectionAlias")
46
47	jsonEncoder := smithyjson.NewEncoder()
48	if err := awsAwsjson11_serializeOpDocumentAssociateConnectionAliasInput(input, jsonEncoder.Value); err != nil {
49		return out, metadata, &smithy.SerializationError{Err: err}
50	}
51
52	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
53		return out, metadata, &smithy.SerializationError{Err: err}
54	}
55
56	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
57		return out, metadata, &smithy.SerializationError{Err: err}
58	}
59	in.Request = request
60
61	return next.HandleSerialize(ctx, in)
62}
63
64type awsAwsjson11_serializeOpAssociateIpGroups struct {
65}
66
67func (*awsAwsjson11_serializeOpAssociateIpGroups) ID() string {
68	return "OperationSerializer"
69}
70
71func (m *awsAwsjson11_serializeOpAssociateIpGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
72	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
73) {
74	request, ok := in.Request.(*smithyhttp.Request)
75	if !ok {
76		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
77	}
78
79	input, ok := in.Parameters.(*AssociateIpGroupsInput)
80	_ = input
81	if !ok {
82		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
83	}
84
85	request.Request.URL.Path = "/"
86	request.Request.Method = "POST"
87	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
88	if err != nil {
89		return out, metadata, &smithy.SerializationError{Err: err}
90	}
91	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
92	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.AssociateIpGroups")
93
94	jsonEncoder := smithyjson.NewEncoder()
95	if err := awsAwsjson11_serializeOpDocumentAssociateIpGroupsInput(input, jsonEncoder.Value); err != nil {
96		return out, metadata, &smithy.SerializationError{Err: err}
97	}
98
99	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
100		return out, metadata, &smithy.SerializationError{Err: err}
101	}
102
103	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
104		return out, metadata, &smithy.SerializationError{Err: err}
105	}
106	in.Request = request
107
108	return next.HandleSerialize(ctx, in)
109}
110
111type awsAwsjson11_serializeOpAuthorizeIpRules struct {
112}
113
114func (*awsAwsjson11_serializeOpAuthorizeIpRules) ID() string {
115	return "OperationSerializer"
116}
117
118func (m *awsAwsjson11_serializeOpAuthorizeIpRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
119	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
120) {
121	request, ok := in.Request.(*smithyhttp.Request)
122	if !ok {
123		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
124	}
125
126	input, ok := in.Parameters.(*AuthorizeIpRulesInput)
127	_ = input
128	if !ok {
129		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
130	}
131
132	request.Request.URL.Path = "/"
133	request.Request.Method = "POST"
134	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
135	if err != nil {
136		return out, metadata, &smithy.SerializationError{Err: err}
137	}
138	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
139	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.AuthorizeIpRules")
140
141	jsonEncoder := smithyjson.NewEncoder()
142	if err := awsAwsjson11_serializeOpDocumentAuthorizeIpRulesInput(input, jsonEncoder.Value); err != nil {
143		return out, metadata, &smithy.SerializationError{Err: err}
144	}
145
146	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
147		return out, metadata, &smithy.SerializationError{Err: err}
148	}
149
150	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
151		return out, metadata, &smithy.SerializationError{Err: err}
152	}
153	in.Request = request
154
155	return next.HandleSerialize(ctx, in)
156}
157
158type awsAwsjson11_serializeOpCopyWorkspaceImage struct {
159}
160
161func (*awsAwsjson11_serializeOpCopyWorkspaceImage) ID() string {
162	return "OperationSerializer"
163}
164
165func (m *awsAwsjson11_serializeOpCopyWorkspaceImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
166	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
167) {
168	request, ok := in.Request.(*smithyhttp.Request)
169	if !ok {
170		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
171	}
172
173	input, ok := in.Parameters.(*CopyWorkspaceImageInput)
174	_ = input
175	if !ok {
176		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
177	}
178
179	request.Request.URL.Path = "/"
180	request.Request.Method = "POST"
181	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
182	if err != nil {
183		return out, metadata, &smithy.SerializationError{Err: err}
184	}
185	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
186	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.CopyWorkspaceImage")
187
188	jsonEncoder := smithyjson.NewEncoder()
189	if err := awsAwsjson11_serializeOpDocumentCopyWorkspaceImageInput(input, jsonEncoder.Value); err != nil {
190		return out, metadata, &smithy.SerializationError{Err: err}
191	}
192
193	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
194		return out, metadata, &smithy.SerializationError{Err: err}
195	}
196
197	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
198		return out, metadata, &smithy.SerializationError{Err: err}
199	}
200	in.Request = request
201
202	return next.HandleSerialize(ctx, in)
203}
204
205type awsAwsjson11_serializeOpCreateConnectionAlias struct {
206}
207
208func (*awsAwsjson11_serializeOpCreateConnectionAlias) ID() string {
209	return "OperationSerializer"
210}
211
212func (m *awsAwsjson11_serializeOpCreateConnectionAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
213	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
214) {
215	request, ok := in.Request.(*smithyhttp.Request)
216	if !ok {
217		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
218	}
219
220	input, ok := in.Parameters.(*CreateConnectionAliasInput)
221	_ = input
222	if !ok {
223		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
224	}
225
226	request.Request.URL.Path = "/"
227	request.Request.Method = "POST"
228	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
229	if err != nil {
230		return out, metadata, &smithy.SerializationError{Err: err}
231	}
232	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
233	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.CreateConnectionAlias")
234
235	jsonEncoder := smithyjson.NewEncoder()
236	if err := awsAwsjson11_serializeOpDocumentCreateConnectionAliasInput(input, jsonEncoder.Value); err != nil {
237		return out, metadata, &smithy.SerializationError{Err: err}
238	}
239
240	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
241		return out, metadata, &smithy.SerializationError{Err: err}
242	}
243
244	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
245		return out, metadata, &smithy.SerializationError{Err: err}
246	}
247	in.Request = request
248
249	return next.HandleSerialize(ctx, in)
250}
251
252type awsAwsjson11_serializeOpCreateIpGroup struct {
253}
254
255func (*awsAwsjson11_serializeOpCreateIpGroup) ID() string {
256	return "OperationSerializer"
257}
258
259func (m *awsAwsjson11_serializeOpCreateIpGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
260	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
261) {
262	request, ok := in.Request.(*smithyhttp.Request)
263	if !ok {
264		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
265	}
266
267	input, ok := in.Parameters.(*CreateIpGroupInput)
268	_ = input
269	if !ok {
270		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
271	}
272
273	request.Request.URL.Path = "/"
274	request.Request.Method = "POST"
275	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
276	if err != nil {
277		return out, metadata, &smithy.SerializationError{Err: err}
278	}
279	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
280	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.CreateIpGroup")
281
282	jsonEncoder := smithyjson.NewEncoder()
283	if err := awsAwsjson11_serializeOpDocumentCreateIpGroupInput(input, jsonEncoder.Value); err != nil {
284		return out, metadata, &smithy.SerializationError{Err: err}
285	}
286
287	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
288		return out, metadata, &smithy.SerializationError{Err: err}
289	}
290
291	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
292		return out, metadata, &smithy.SerializationError{Err: err}
293	}
294	in.Request = request
295
296	return next.HandleSerialize(ctx, in)
297}
298
299type awsAwsjson11_serializeOpCreateTags struct {
300}
301
302func (*awsAwsjson11_serializeOpCreateTags) ID() string {
303	return "OperationSerializer"
304}
305
306func (m *awsAwsjson11_serializeOpCreateTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
307	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
308) {
309	request, ok := in.Request.(*smithyhttp.Request)
310	if !ok {
311		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
312	}
313
314	input, ok := in.Parameters.(*CreateTagsInput)
315	_ = input
316	if !ok {
317		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
318	}
319
320	request.Request.URL.Path = "/"
321	request.Request.Method = "POST"
322	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
323	if err != nil {
324		return out, metadata, &smithy.SerializationError{Err: err}
325	}
326	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
327	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.CreateTags")
328
329	jsonEncoder := smithyjson.NewEncoder()
330	if err := awsAwsjson11_serializeOpDocumentCreateTagsInput(input, jsonEncoder.Value); err != nil {
331		return out, metadata, &smithy.SerializationError{Err: err}
332	}
333
334	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
335		return out, metadata, &smithy.SerializationError{Err: err}
336	}
337
338	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
339		return out, metadata, &smithy.SerializationError{Err: err}
340	}
341	in.Request = request
342
343	return next.HandleSerialize(ctx, in)
344}
345
346type awsAwsjson11_serializeOpCreateWorkspaceBundle struct {
347}
348
349func (*awsAwsjson11_serializeOpCreateWorkspaceBundle) ID() string {
350	return "OperationSerializer"
351}
352
353func (m *awsAwsjson11_serializeOpCreateWorkspaceBundle) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
354	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
355) {
356	request, ok := in.Request.(*smithyhttp.Request)
357	if !ok {
358		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
359	}
360
361	input, ok := in.Parameters.(*CreateWorkspaceBundleInput)
362	_ = input
363	if !ok {
364		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
365	}
366
367	request.Request.URL.Path = "/"
368	request.Request.Method = "POST"
369	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
370	if err != nil {
371		return out, metadata, &smithy.SerializationError{Err: err}
372	}
373	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
374	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.CreateWorkspaceBundle")
375
376	jsonEncoder := smithyjson.NewEncoder()
377	if err := awsAwsjson11_serializeOpDocumentCreateWorkspaceBundleInput(input, jsonEncoder.Value); err != nil {
378		return out, metadata, &smithy.SerializationError{Err: err}
379	}
380
381	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
382		return out, metadata, &smithy.SerializationError{Err: err}
383	}
384
385	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
386		return out, metadata, &smithy.SerializationError{Err: err}
387	}
388	in.Request = request
389
390	return next.HandleSerialize(ctx, in)
391}
392
393type awsAwsjson11_serializeOpCreateWorkspaces struct {
394}
395
396func (*awsAwsjson11_serializeOpCreateWorkspaces) ID() string {
397	return "OperationSerializer"
398}
399
400func (m *awsAwsjson11_serializeOpCreateWorkspaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
401	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
402) {
403	request, ok := in.Request.(*smithyhttp.Request)
404	if !ok {
405		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
406	}
407
408	input, ok := in.Parameters.(*CreateWorkspacesInput)
409	_ = input
410	if !ok {
411		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
412	}
413
414	request.Request.URL.Path = "/"
415	request.Request.Method = "POST"
416	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
417	if err != nil {
418		return out, metadata, &smithy.SerializationError{Err: err}
419	}
420	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
421	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.CreateWorkspaces")
422
423	jsonEncoder := smithyjson.NewEncoder()
424	if err := awsAwsjson11_serializeOpDocumentCreateWorkspacesInput(input, jsonEncoder.Value); err != nil {
425		return out, metadata, &smithy.SerializationError{Err: err}
426	}
427
428	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
429		return out, metadata, &smithy.SerializationError{Err: err}
430	}
431
432	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
433		return out, metadata, &smithy.SerializationError{Err: err}
434	}
435	in.Request = request
436
437	return next.HandleSerialize(ctx, in)
438}
439
440type awsAwsjson11_serializeOpDeleteConnectionAlias struct {
441}
442
443func (*awsAwsjson11_serializeOpDeleteConnectionAlias) ID() string {
444	return "OperationSerializer"
445}
446
447func (m *awsAwsjson11_serializeOpDeleteConnectionAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
448	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
449) {
450	request, ok := in.Request.(*smithyhttp.Request)
451	if !ok {
452		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
453	}
454
455	input, ok := in.Parameters.(*DeleteConnectionAliasInput)
456	_ = input
457	if !ok {
458		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
459	}
460
461	request.Request.URL.Path = "/"
462	request.Request.Method = "POST"
463	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
464	if err != nil {
465		return out, metadata, &smithy.SerializationError{Err: err}
466	}
467	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
468	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DeleteConnectionAlias")
469
470	jsonEncoder := smithyjson.NewEncoder()
471	if err := awsAwsjson11_serializeOpDocumentDeleteConnectionAliasInput(input, jsonEncoder.Value); err != nil {
472		return out, metadata, &smithy.SerializationError{Err: err}
473	}
474
475	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
476		return out, metadata, &smithy.SerializationError{Err: err}
477	}
478
479	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
480		return out, metadata, &smithy.SerializationError{Err: err}
481	}
482	in.Request = request
483
484	return next.HandleSerialize(ctx, in)
485}
486
487type awsAwsjson11_serializeOpDeleteIpGroup struct {
488}
489
490func (*awsAwsjson11_serializeOpDeleteIpGroup) ID() string {
491	return "OperationSerializer"
492}
493
494func (m *awsAwsjson11_serializeOpDeleteIpGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
495	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
496) {
497	request, ok := in.Request.(*smithyhttp.Request)
498	if !ok {
499		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
500	}
501
502	input, ok := in.Parameters.(*DeleteIpGroupInput)
503	_ = input
504	if !ok {
505		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
506	}
507
508	request.Request.URL.Path = "/"
509	request.Request.Method = "POST"
510	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
511	if err != nil {
512		return out, metadata, &smithy.SerializationError{Err: err}
513	}
514	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
515	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DeleteIpGroup")
516
517	jsonEncoder := smithyjson.NewEncoder()
518	if err := awsAwsjson11_serializeOpDocumentDeleteIpGroupInput(input, jsonEncoder.Value); err != nil {
519		return out, metadata, &smithy.SerializationError{Err: err}
520	}
521
522	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
523		return out, metadata, &smithy.SerializationError{Err: err}
524	}
525
526	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
527		return out, metadata, &smithy.SerializationError{Err: err}
528	}
529	in.Request = request
530
531	return next.HandleSerialize(ctx, in)
532}
533
534type awsAwsjson11_serializeOpDeleteTags struct {
535}
536
537func (*awsAwsjson11_serializeOpDeleteTags) ID() string {
538	return "OperationSerializer"
539}
540
541func (m *awsAwsjson11_serializeOpDeleteTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
542	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
543) {
544	request, ok := in.Request.(*smithyhttp.Request)
545	if !ok {
546		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
547	}
548
549	input, ok := in.Parameters.(*DeleteTagsInput)
550	_ = input
551	if !ok {
552		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
553	}
554
555	request.Request.URL.Path = "/"
556	request.Request.Method = "POST"
557	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
558	if err != nil {
559		return out, metadata, &smithy.SerializationError{Err: err}
560	}
561	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
562	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DeleteTags")
563
564	jsonEncoder := smithyjson.NewEncoder()
565	if err := awsAwsjson11_serializeOpDocumentDeleteTagsInput(input, jsonEncoder.Value); err != nil {
566		return out, metadata, &smithy.SerializationError{Err: err}
567	}
568
569	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
570		return out, metadata, &smithy.SerializationError{Err: err}
571	}
572
573	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
574		return out, metadata, &smithy.SerializationError{Err: err}
575	}
576	in.Request = request
577
578	return next.HandleSerialize(ctx, in)
579}
580
581type awsAwsjson11_serializeOpDeleteWorkspaceBundle struct {
582}
583
584func (*awsAwsjson11_serializeOpDeleteWorkspaceBundle) ID() string {
585	return "OperationSerializer"
586}
587
588func (m *awsAwsjson11_serializeOpDeleteWorkspaceBundle) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
589	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
590) {
591	request, ok := in.Request.(*smithyhttp.Request)
592	if !ok {
593		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
594	}
595
596	input, ok := in.Parameters.(*DeleteWorkspaceBundleInput)
597	_ = input
598	if !ok {
599		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
600	}
601
602	request.Request.URL.Path = "/"
603	request.Request.Method = "POST"
604	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
605	if err != nil {
606		return out, metadata, &smithy.SerializationError{Err: err}
607	}
608	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
609	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DeleteWorkspaceBundle")
610
611	jsonEncoder := smithyjson.NewEncoder()
612	if err := awsAwsjson11_serializeOpDocumentDeleteWorkspaceBundleInput(input, jsonEncoder.Value); err != nil {
613		return out, metadata, &smithy.SerializationError{Err: err}
614	}
615
616	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
617		return out, metadata, &smithy.SerializationError{Err: err}
618	}
619
620	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
621		return out, metadata, &smithy.SerializationError{Err: err}
622	}
623	in.Request = request
624
625	return next.HandleSerialize(ctx, in)
626}
627
628type awsAwsjson11_serializeOpDeleteWorkspaceImage struct {
629}
630
631func (*awsAwsjson11_serializeOpDeleteWorkspaceImage) ID() string {
632	return "OperationSerializer"
633}
634
635func (m *awsAwsjson11_serializeOpDeleteWorkspaceImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
636	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
637) {
638	request, ok := in.Request.(*smithyhttp.Request)
639	if !ok {
640		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
641	}
642
643	input, ok := in.Parameters.(*DeleteWorkspaceImageInput)
644	_ = input
645	if !ok {
646		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
647	}
648
649	request.Request.URL.Path = "/"
650	request.Request.Method = "POST"
651	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
652	if err != nil {
653		return out, metadata, &smithy.SerializationError{Err: err}
654	}
655	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
656	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DeleteWorkspaceImage")
657
658	jsonEncoder := smithyjson.NewEncoder()
659	if err := awsAwsjson11_serializeOpDocumentDeleteWorkspaceImageInput(input, jsonEncoder.Value); err != nil {
660		return out, metadata, &smithy.SerializationError{Err: err}
661	}
662
663	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
664		return out, metadata, &smithy.SerializationError{Err: err}
665	}
666
667	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
668		return out, metadata, &smithy.SerializationError{Err: err}
669	}
670	in.Request = request
671
672	return next.HandleSerialize(ctx, in)
673}
674
675type awsAwsjson11_serializeOpDeregisterWorkspaceDirectory struct {
676}
677
678func (*awsAwsjson11_serializeOpDeregisterWorkspaceDirectory) ID() string {
679	return "OperationSerializer"
680}
681
682func (m *awsAwsjson11_serializeOpDeregisterWorkspaceDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
683	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
684) {
685	request, ok := in.Request.(*smithyhttp.Request)
686	if !ok {
687		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
688	}
689
690	input, ok := in.Parameters.(*DeregisterWorkspaceDirectoryInput)
691	_ = input
692	if !ok {
693		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
694	}
695
696	request.Request.URL.Path = "/"
697	request.Request.Method = "POST"
698	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
699	if err != nil {
700		return out, metadata, &smithy.SerializationError{Err: err}
701	}
702	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
703	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DeregisterWorkspaceDirectory")
704
705	jsonEncoder := smithyjson.NewEncoder()
706	if err := awsAwsjson11_serializeOpDocumentDeregisterWorkspaceDirectoryInput(input, jsonEncoder.Value); err != nil {
707		return out, metadata, &smithy.SerializationError{Err: err}
708	}
709
710	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
711		return out, metadata, &smithy.SerializationError{Err: err}
712	}
713
714	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
715		return out, metadata, &smithy.SerializationError{Err: err}
716	}
717	in.Request = request
718
719	return next.HandleSerialize(ctx, in)
720}
721
722type awsAwsjson11_serializeOpDescribeAccount struct {
723}
724
725func (*awsAwsjson11_serializeOpDescribeAccount) ID() string {
726	return "OperationSerializer"
727}
728
729func (m *awsAwsjson11_serializeOpDescribeAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
730	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
731) {
732	request, ok := in.Request.(*smithyhttp.Request)
733	if !ok {
734		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
735	}
736
737	input, ok := in.Parameters.(*DescribeAccountInput)
738	_ = input
739	if !ok {
740		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
741	}
742
743	request.Request.URL.Path = "/"
744	request.Request.Method = "POST"
745	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
746	if err != nil {
747		return out, metadata, &smithy.SerializationError{Err: err}
748	}
749	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
750	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeAccount")
751
752	jsonEncoder := smithyjson.NewEncoder()
753	if err := awsAwsjson11_serializeOpDocumentDescribeAccountInput(input, jsonEncoder.Value); err != nil {
754		return out, metadata, &smithy.SerializationError{Err: err}
755	}
756
757	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
758		return out, metadata, &smithy.SerializationError{Err: err}
759	}
760
761	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
762		return out, metadata, &smithy.SerializationError{Err: err}
763	}
764	in.Request = request
765
766	return next.HandleSerialize(ctx, in)
767}
768
769type awsAwsjson11_serializeOpDescribeAccountModifications struct {
770}
771
772func (*awsAwsjson11_serializeOpDescribeAccountModifications) ID() string {
773	return "OperationSerializer"
774}
775
776func (m *awsAwsjson11_serializeOpDescribeAccountModifications) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
777	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
778) {
779	request, ok := in.Request.(*smithyhttp.Request)
780	if !ok {
781		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
782	}
783
784	input, ok := in.Parameters.(*DescribeAccountModificationsInput)
785	_ = input
786	if !ok {
787		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
788	}
789
790	request.Request.URL.Path = "/"
791	request.Request.Method = "POST"
792	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
793	if err != nil {
794		return out, metadata, &smithy.SerializationError{Err: err}
795	}
796	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
797	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeAccountModifications")
798
799	jsonEncoder := smithyjson.NewEncoder()
800	if err := awsAwsjson11_serializeOpDocumentDescribeAccountModificationsInput(input, jsonEncoder.Value); err != nil {
801		return out, metadata, &smithy.SerializationError{Err: err}
802	}
803
804	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
805		return out, metadata, &smithy.SerializationError{Err: err}
806	}
807
808	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
809		return out, metadata, &smithy.SerializationError{Err: err}
810	}
811	in.Request = request
812
813	return next.HandleSerialize(ctx, in)
814}
815
816type awsAwsjson11_serializeOpDescribeClientProperties struct {
817}
818
819func (*awsAwsjson11_serializeOpDescribeClientProperties) ID() string {
820	return "OperationSerializer"
821}
822
823func (m *awsAwsjson11_serializeOpDescribeClientProperties) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
824	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
825) {
826	request, ok := in.Request.(*smithyhttp.Request)
827	if !ok {
828		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
829	}
830
831	input, ok := in.Parameters.(*DescribeClientPropertiesInput)
832	_ = input
833	if !ok {
834		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
835	}
836
837	request.Request.URL.Path = "/"
838	request.Request.Method = "POST"
839	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
840	if err != nil {
841		return out, metadata, &smithy.SerializationError{Err: err}
842	}
843	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
844	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeClientProperties")
845
846	jsonEncoder := smithyjson.NewEncoder()
847	if err := awsAwsjson11_serializeOpDocumentDescribeClientPropertiesInput(input, jsonEncoder.Value); err != nil {
848		return out, metadata, &smithy.SerializationError{Err: err}
849	}
850
851	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
852		return out, metadata, &smithy.SerializationError{Err: err}
853	}
854
855	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
856		return out, metadata, &smithy.SerializationError{Err: err}
857	}
858	in.Request = request
859
860	return next.HandleSerialize(ctx, in)
861}
862
863type awsAwsjson11_serializeOpDescribeConnectionAliases struct {
864}
865
866func (*awsAwsjson11_serializeOpDescribeConnectionAliases) ID() string {
867	return "OperationSerializer"
868}
869
870func (m *awsAwsjson11_serializeOpDescribeConnectionAliases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
871	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
872) {
873	request, ok := in.Request.(*smithyhttp.Request)
874	if !ok {
875		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
876	}
877
878	input, ok := in.Parameters.(*DescribeConnectionAliasesInput)
879	_ = input
880	if !ok {
881		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
882	}
883
884	request.Request.URL.Path = "/"
885	request.Request.Method = "POST"
886	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
887	if err != nil {
888		return out, metadata, &smithy.SerializationError{Err: err}
889	}
890	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
891	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeConnectionAliases")
892
893	jsonEncoder := smithyjson.NewEncoder()
894	if err := awsAwsjson11_serializeOpDocumentDescribeConnectionAliasesInput(input, jsonEncoder.Value); err != nil {
895		return out, metadata, &smithy.SerializationError{Err: err}
896	}
897
898	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
899		return out, metadata, &smithy.SerializationError{Err: err}
900	}
901
902	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
903		return out, metadata, &smithy.SerializationError{Err: err}
904	}
905	in.Request = request
906
907	return next.HandleSerialize(ctx, in)
908}
909
910type awsAwsjson11_serializeOpDescribeConnectionAliasPermissions struct {
911}
912
913func (*awsAwsjson11_serializeOpDescribeConnectionAliasPermissions) ID() string {
914	return "OperationSerializer"
915}
916
917func (m *awsAwsjson11_serializeOpDescribeConnectionAliasPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
918	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
919) {
920	request, ok := in.Request.(*smithyhttp.Request)
921	if !ok {
922		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
923	}
924
925	input, ok := in.Parameters.(*DescribeConnectionAliasPermissionsInput)
926	_ = input
927	if !ok {
928		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
929	}
930
931	request.Request.URL.Path = "/"
932	request.Request.Method = "POST"
933	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
934	if err != nil {
935		return out, metadata, &smithy.SerializationError{Err: err}
936	}
937	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
938	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeConnectionAliasPermissions")
939
940	jsonEncoder := smithyjson.NewEncoder()
941	if err := awsAwsjson11_serializeOpDocumentDescribeConnectionAliasPermissionsInput(input, jsonEncoder.Value); err != nil {
942		return out, metadata, &smithy.SerializationError{Err: err}
943	}
944
945	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
946		return out, metadata, &smithy.SerializationError{Err: err}
947	}
948
949	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
950		return out, metadata, &smithy.SerializationError{Err: err}
951	}
952	in.Request = request
953
954	return next.HandleSerialize(ctx, in)
955}
956
957type awsAwsjson11_serializeOpDescribeIpGroups struct {
958}
959
960func (*awsAwsjson11_serializeOpDescribeIpGroups) ID() string {
961	return "OperationSerializer"
962}
963
964func (m *awsAwsjson11_serializeOpDescribeIpGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
965	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
966) {
967	request, ok := in.Request.(*smithyhttp.Request)
968	if !ok {
969		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
970	}
971
972	input, ok := in.Parameters.(*DescribeIpGroupsInput)
973	_ = input
974	if !ok {
975		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
976	}
977
978	request.Request.URL.Path = "/"
979	request.Request.Method = "POST"
980	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
981	if err != nil {
982		return out, metadata, &smithy.SerializationError{Err: err}
983	}
984	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
985	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeIpGroups")
986
987	jsonEncoder := smithyjson.NewEncoder()
988	if err := awsAwsjson11_serializeOpDocumentDescribeIpGroupsInput(input, jsonEncoder.Value); err != nil {
989		return out, metadata, &smithy.SerializationError{Err: err}
990	}
991
992	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
993		return out, metadata, &smithy.SerializationError{Err: err}
994	}
995
996	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
997		return out, metadata, &smithy.SerializationError{Err: err}
998	}
999	in.Request = request
1000
1001	return next.HandleSerialize(ctx, in)
1002}
1003
1004type awsAwsjson11_serializeOpDescribeTags struct {
1005}
1006
1007func (*awsAwsjson11_serializeOpDescribeTags) ID() string {
1008	return "OperationSerializer"
1009}
1010
1011func (m *awsAwsjson11_serializeOpDescribeTags) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1012	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1013) {
1014	request, ok := in.Request.(*smithyhttp.Request)
1015	if !ok {
1016		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1017	}
1018
1019	input, ok := in.Parameters.(*DescribeTagsInput)
1020	_ = input
1021	if !ok {
1022		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1023	}
1024
1025	request.Request.URL.Path = "/"
1026	request.Request.Method = "POST"
1027	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1028	if err != nil {
1029		return out, metadata, &smithy.SerializationError{Err: err}
1030	}
1031	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1032	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeTags")
1033
1034	jsonEncoder := smithyjson.NewEncoder()
1035	if err := awsAwsjson11_serializeOpDocumentDescribeTagsInput(input, jsonEncoder.Value); err != nil {
1036		return out, metadata, &smithy.SerializationError{Err: err}
1037	}
1038
1039	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1040		return out, metadata, &smithy.SerializationError{Err: err}
1041	}
1042
1043	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1044		return out, metadata, &smithy.SerializationError{Err: err}
1045	}
1046	in.Request = request
1047
1048	return next.HandleSerialize(ctx, in)
1049}
1050
1051type awsAwsjson11_serializeOpDescribeWorkspaceBundles struct {
1052}
1053
1054func (*awsAwsjson11_serializeOpDescribeWorkspaceBundles) ID() string {
1055	return "OperationSerializer"
1056}
1057
1058func (m *awsAwsjson11_serializeOpDescribeWorkspaceBundles) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1059	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1060) {
1061	request, ok := in.Request.(*smithyhttp.Request)
1062	if !ok {
1063		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1064	}
1065
1066	input, ok := in.Parameters.(*DescribeWorkspaceBundlesInput)
1067	_ = input
1068	if !ok {
1069		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1070	}
1071
1072	request.Request.URL.Path = "/"
1073	request.Request.Method = "POST"
1074	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1075	if err != nil {
1076		return out, metadata, &smithy.SerializationError{Err: err}
1077	}
1078	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1079	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeWorkspaceBundles")
1080
1081	jsonEncoder := smithyjson.NewEncoder()
1082	if err := awsAwsjson11_serializeOpDocumentDescribeWorkspaceBundlesInput(input, jsonEncoder.Value); err != nil {
1083		return out, metadata, &smithy.SerializationError{Err: err}
1084	}
1085
1086	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1087		return out, metadata, &smithy.SerializationError{Err: err}
1088	}
1089
1090	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1091		return out, metadata, &smithy.SerializationError{Err: err}
1092	}
1093	in.Request = request
1094
1095	return next.HandleSerialize(ctx, in)
1096}
1097
1098type awsAwsjson11_serializeOpDescribeWorkspaceDirectories struct {
1099}
1100
1101func (*awsAwsjson11_serializeOpDescribeWorkspaceDirectories) ID() string {
1102	return "OperationSerializer"
1103}
1104
1105func (m *awsAwsjson11_serializeOpDescribeWorkspaceDirectories) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1106	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1107) {
1108	request, ok := in.Request.(*smithyhttp.Request)
1109	if !ok {
1110		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1111	}
1112
1113	input, ok := in.Parameters.(*DescribeWorkspaceDirectoriesInput)
1114	_ = input
1115	if !ok {
1116		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1117	}
1118
1119	request.Request.URL.Path = "/"
1120	request.Request.Method = "POST"
1121	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1122	if err != nil {
1123		return out, metadata, &smithy.SerializationError{Err: err}
1124	}
1125	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1126	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeWorkspaceDirectories")
1127
1128	jsonEncoder := smithyjson.NewEncoder()
1129	if err := awsAwsjson11_serializeOpDocumentDescribeWorkspaceDirectoriesInput(input, jsonEncoder.Value); err != nil {
1130		return out, metadata, &smithy.SerializationError{Err: err}
1131	}
1132
1133	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1134		return out, metadata, &smithy.SerializationError{Err: err}
1135	}
1136
1137	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1138		return out, metadata, &smithy.SerializationError{Err: err}
1139	}
1140	in.Request = request
1141
1142	return next.HandleSerialize(ctx, in)
1143}
1144
1145type awsAwsjson11_serializeOpDescribeWorkspaceImagePermissions struct {
1146}
1147
1148func (*awsAwsjson11_serializeOpDescribeWorkspaceImagePermissions) ID() string {
1149	return "OperationSerializer"
1150}
1151
1152func (m *awsAwsjson11_serializeOpDescribeWorkspaceImagePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1153	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1154) {
1155	request, ok := in.Request.(*smithyhttp.Request)
1156	if !ok {
1157		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1158	}
1159
1160	input, ok := in.Parameters.(*DescribeWorkspaceImagePermissionsInput)
1161	_ = input
1162	if !ok {
1163		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1164	}
1165
1166	request.Request.URL.Path = "/"
1167	request.Request.Method = "POST"
1168	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1169	if err != nil {
1170		return out, metadata, &smithy.SerializationError{Err: err}
1171	}
1172	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1173	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeWorkspaceImagePermissions")
1174
1175	jsonEncoder := smithyjson.NewEncoder()
1176	if err := awsAwsjson11_serializeOpDocumentDescribeWorkspaceImagePermissionsInput(input, jsonEncoder.Value); err != nil {
1177		return out, metadata, &smithy.SerializationError{Err: err}
1178	}
1179
1180	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1181		return out, metadata, &smithy.SerializationError{Err: err}
1182	}
1183
1184	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1185		return out, metadata, &smithy.SerializationError{Err: err}
1186	}
1187	in.Request = request
1188
1189	return next.HandleSerialize(ctx, in)
1190}
1191
1192type awsAwsjson11_serializeOpDescribeWorkspaceImages struct {
1193}
1194
1195func (*awsAwsjson11_serializeOpDescribeWorkspaceImages) ID() string {
1196	return "OperationSerializer"
1197}
1198
1199func (m *awsAwsjson11_serializeOpDescribeWorkspaceImages) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1200	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1201) {
1202	request, ok := in.Request.(*smithyhttp.Request)
1203	if !ok {
1204		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1205	}
1206
1207	input, ok := in.Parameters.(*DescribeWorkspaceImagesInput)
1208	_ = input
1209	if !ok {
1210		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1211	}
1212
1213	request.Request.URL.Path = "/"
1214	request.Request.Method = "POST"
1215	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1216	if err != nil {
1217		return out, metadata, &smithy.SerializationError{Err: err}
1218	}
1219	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1220	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeWorkspaceImages")
1221
1222	jsonEncoder := smithyjson.NewEncoder()
1223	if err := awsAwsjson11_serializeOpDocumentDescribeWorkspaceImagesInput(input, jsonEncoder.Value); err != nil {
1224		return out, metadata, &smithy.SerializationError{Err: err}
1225	}
1226
1227	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1228		return out, metadata, &smithy.SerializationError{Err: err}
1229	}
1230
1231	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1232		return out, metadata, &smithy.SerializationError{Err: err}
1233	}
1234	in.Request = request
1235
1236	return next.HandleSerialize(ctx, in)
1237}
1238
1239type awsAwsjson11_serializeOpDescribeWorkspaces struct {
1240}
1241
1242func (*awsAwsjson11_serializeOpDescribeWorkspaces) ID() string {
1243	return "OperationSerializer"
1244}
1245
1246func (m *awsAwsjson11_serializeOpDescribeWorkspaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1247	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1248) {
1249	request, ok := in.Request.(*smithyhttp.Request)
1250	if !ok {
1251		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1252	}
1253
1254	input, ok := in.Parameters.(*DescribeWorkspacesInput)
1255	_ = input
1256	if !ok {
1257		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1258	}
1259
1260	request.Request.URL.Path = "/"
1261	request.Request.Method = "POST"
1262	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1263	if err != nil {
1264		return out, metadata, &smithy.SerializationError{Err: err}
1265	}
1266	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1267	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeWorkspaces")
1268
1269	jsonEncoder := smithyjson.NewEncoder()
1270	if err := awsAwsjson11_serializeOpDocumentDescribeWorkspacesInput(input, jsonEncoder.Value); err != nil {
1271		return out, metadata, &smithy.SerializationError{Err: err}
1272	}
1273
1274	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1275		return out, metadata, &smithy.SerializationError{Err: err}
1276	}
1277
1278	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1279		return out, metadata, &smithy.SerializationError{Err: err}
1280	}
1281	in.Request = request
1282
1283	return next.HandleSerialize(ctx, in)
1284}
1285
1286type awsAwsjson11_serializeOpDescribeWorkspacesConnectionStatus struct {
1287}
1288
1289func (*awsAwsjson11_serializeOpDescribeWorkspacesConnectionStatus) ID() string {
1290	return "OperationSerializer"
1291}
1292
1293func (m *awsAwsjson11_serializeOpDescribeWorkspacesConnectionStatus) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1294	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1295) {
1296	request, ok := in.Request.(*smithyhttp.Request)
1297	if !ok {
1298		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1299	}
1300
1301	input, ok := in.Parameters.(*DescribeWorkspacesConnectionStatusInput)
1302	_ = input
1303	if !ok {
1304		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1305	}
1306
1307	request.Request.URL.Path = "/"
1308	request.Request.Method = "POST"
1309	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1310	if err != nil {
1311		return out, metadata, &smithy.SerializationError{Err: err}
1312	}
1313	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1314	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeWorkspacesConnectionStatus")
1315
1316	jsonEncoder := smithyjson.NewEncoder()
1317	if err := awsAwsjson11_serializeOpDocumentDescribeWorkspacesConnectionStatusInput(input, jsonEncoder.Value); err != nil {
1318		return out, metadata, &smithy.SerializationError{Err: err}
1319	}
1320
1321	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1322		return out, metadata, &smithy.SerializationError{Err: err}
1323	}
1324
1325	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1326		return out, metadata, &smithy.SerializationError{Err: err}
1327	}
1328	in.Request = request
1329
1330	return next.HandleSerialize(ctx, in)
1331}
1332
1333type awsAwsjson11_serializeOpDescribeWorkspaceSnapshots struct {
1334}
1335
1336func (*awsAwsjson11_serializeOpDescribeWorkspaceSnapshots) ID() string {
1337	return "OperationSerializer"
1338}
1339
1340func (m *awsAwsjson11_serializeOpDescribeWorkspaceSnapshots) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1341	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1342) {
1343	request, ok := in.Request.(*smithyhttp.Request)
1344	if !ok {
1345		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1346	}
1347
1348	input, ok := in.Parameters.(*DescribeWorkspaceSnapshotsInput)
1349	_ = input
1350	if !ok {
1351		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1352	}
1353
1354	request.Request.URL.Path = "/"
1355	request.Request.Method = "POST"
1356	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1357	if err != nil {
1358		return out, metadata, &smithy.SerializationError{Err: err}
1359	}
1360	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1361	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DescribeWorkspaceSnapshots")
1362
1363	jsonEncoder := smithyjson.NewEncoder()
1364	if err := awsAwsjson11_serializeOpDocumentDescribeWorkspaceSnapshotsInput(input, jsonEncoder.Value); err != nil {
1365		return out, metadata, &smithy.SerializationError{Err: err}
1366	}
1367
1368	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1369		return out, metadata, &smithy.SerializationError{Err: err}
1370	}
1371
1372	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1373		return out, metadata, &smithy.SerializationError{Err: err}
1374	}
1375	in.Request = request
1376
1377	return next.HandleSerialize(ctx, in)
1378}
1379
1380type awsAwsjson11_serializeOpDisassociateConnectionAlias struct {
1381}
1382
1383func (*awsAwsjson11_serializeOpDisassociateConnectionAlias) ID() string {
1384	return "OperationSerializer"
1385}
1386
1387func (m *awsAwsjson11_serializeOpDisassociateConnectionAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1388	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1389) {
1390	request, ok := in.Request.(*smithyhttp.Request)
1391	if !ok {
1392		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1393	}
1394
1395	input, ok := in.Parameters.(*DisassociateConnectionAliasInput)
1396	_ = input
1397	if !ok {
1398		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1399	}
1400
1401	request.Request.URL.Path = "/"
1402	request.Request.Method = "POST"
1403	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1404	if err != nil {
1405		return out, metadata, &smithy.SerializationError{Err: err}
1406	}
1407	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1408	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DisassociateConnectionAlias")
1409
1410	jsonEncoder := smithyjson.NewEncoder()
1411	if err := awsAwsjson11_serializeOpDocumentDisassociateConnectionAliasInput(input, jsonEncoder.Value); err != nil {
1412		return out, metadata, &smithy.SerializationError{Err: err}
1413	}
1414
1415	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1416		return out, metadata, &smithy.SerializationError{Err: err}
1417	}
1418
1419	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1420		return out, metadata, &smithy.SerializationError{Err: err}
1421	}
1422	in.Request = request
1423
1424	return next.HandleSerialize(ctx, in)
1425}
1426
1427type awsAwsjson11_serializeOpDisassociateIpGroups struct {
1428}
1429
1430func (*awsAwsjson11_serializeOpDisassociateIpGroups) ID() string {
1431	return "OperationSerializer"
1432}
1433
1434func (m *awsAwsjson11_serializeOpDisassociateIpGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1435	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1436) {
1437	request, ok := in.Request.(*smithyhttp.Request)
1438	if !ok {
1439		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1440	}
1441
1442	input, ok := in.Parameters.(*DisassociateIpGroupsInput)
1443	_ = input
1444	if !ok {
1445		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1446	}
1447
1448	request.Request.URL.Path = "/"
1449	request.Request.Method = "POST"
1450	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1451	if err != nil {
1452		return out, metadata, &smithy.SerializationError{Err: err}
1453	}
1454	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1455	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.DisassociateIpGroups")
1456
1457	jsonEncoder := smithyjson.NewEncoder()
1458	if err := awsAwsjson11_serializeOpDocumentDisassociateIpGroupsInput(input, jsonEncoder.Value); err != nil {
1459		return out, metadata, &smithy.SerializationError{Err: err}
1460	}
1461
1462	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1463		return out, metadata, &smithy.SerializationError{Err: err}
1464	}
1465
1466	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1467		return out, metadata, &smithy.SerializationError{Err: err}
1468	}
1469	in.Request = request
1470
1471	return next.HandleSerialize(ctx, in)
1472}
1473
1474type awsAwsjson11_serializeOpImportWorkspaceImage struct {
1475}
1476
1477func (*awsAwsjson11_serializeOpImportWorkspaceImage) ID() string {
1478	return "OperationSerializer"
1479}
1480
1481func (m *awsAwsjson11_serializeOpImportWorkspaceImage) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1482	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1483) {
1484	request, ok := in.Request.(*smithyhttp.Request)
1485	if !ok {
1486		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1487	}
1488
1489	input, ok := in.Parameters.(*ImportWorkspaceImageInput)
1490	_ = input
1491	if !ok {
1492		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1493	}
1494
1495	request.Request.URL.Path = "/"
1496	request.Request.Method = "POST"
1497	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1498	if err != nil {
1499		return out, metadata, &smithy.SerializationError{Err: err}
1500	}
1501	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1502	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.ImportWorkspaceImage")
1503
1504	jsonEncoder := smithyjson.NewEncoder()
1505	if err := awsAwsjson11_serializeOpDocumentImportWorkspaceImageInput(input, jsonEncoder.Value); err != nil {
1506		return out, metadata, &smithy.SerializationError{Err: err}
1507	}
1508
1509	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1510		return out, metadata, &smithy.SerializationError{Err: err}
1511	}
1512
1513	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1514		return out, metadata, &smithy.SerializationError{Err: err}
1515	}
1516	in.Request = request
1517
1518	return next.HandleSerialize(ctx, in)
1519}
1520
1521type awsAwsjson11_serializeOpListAvailableManagementCidrRanges struct {
1522}
1523
1524func (*awsAwsjson11_serializeOpListAvailableManagementCidrRanges) ID() string {
1525	return "OperationSerializer"
1526}
1527
1528func (m *awsAwsjson11_serializeOpListAvailableManagementCidrRanges) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1529	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1530) {
1531	request, ok := in.Request.(*smithyhttp.Request)
1532	if !ok {
1533		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1534	}
1535
1536	input, ok := in.Parameters.(*ListAvailableManagementCidrRangesInput)
1537	_ = input
1538	if !ok {
1539		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1540	}
1541
1542	request.Request.URL.Path = "/"
1543	request.Request.Method = "POST"
1544	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1545	if err != nil {
1546		return out, metadata, &smithy.SerializationError{Err: err}
1547	}
1548	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1549	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.ListAvailableManagementCidrRanges")
1550
1551	jsonEncoder := smithyjson.NewEncoder()
1552	if err := awsAwsjson11_serializeOpDocumentListAvailableManagementCidrRangesInput(input, jsonEncoder.Value); err != nil {
1553		return out, metadata, &smithy.SerializationError{Err: err}
1554	}
1555
1556	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1557		return out, metadata, &smithy.SerializationError{Err: err}
1558	}
1559
1560	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1561		return out, metadata, &smithy.SerializationError{Err: err}
1562	}
1563	in.Request = request
1564
1565	return next.HandleSerialize(ctx, in)
1566}
1567
1568type awsAwsjson11_serializeOpMigrateWorkspace struct {
1569}
1570
1571func (*awsAwsjson11_serializeOpMigrateWorkspace) ID() string {
1572	return "OperationSerializer"
1573}
1574
1575func (m *awsAwsjson11_serializeOpMigrateWorkspace) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1576	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1577) {
1578	request, ok := in.Request.(*smithyhttp.Request)
1579	if !ok {
1580		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1581	}
1582
1583	input, ok := in.Parameters.(*MigrateWorkspaceInput)
1584	_ = input
1585	if !ok {
1586		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1587	}
1588
1589	request.Request.URL.Path = "/"
1590	request.Request.Method = "POST"
1591	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1592	if err != nil {
1593		return out, metadata, &smithy.SerializationError{Err: err}
1594	}
1595	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1596	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.MigrateWorkspace")
1597
1598	jsonEncoder := smithyjson.NewEncoder()
1599	if err := awsAwsjson11_serializeOpDocumentMigrateWorkspaceInput(input, jsonEncoder.Value); err != nil {
1600		return out, metadata, &smithy.SerializationError{Err: err}
1601	}
1602
1603	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1604		return out, metadata, &smithy.SerializationError{Err: err}
1605	}
1606
1607	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1608		return out, metadata, &smithy.SerializationError{Err: err}
1609	}
1610	in.Request = request
1611
1612	return next.HandleSerialize(ctx, in)
1613}
1614
1615type awsAwsjson11_serializeOpModifyAccount struct {
1616}
1617
1618func (*awsAwsjson11_serializeOpModifyAccount) ID() string {
1619	return "OperationSerializer"
1620}
1621
1622func (m *awsAwsjson11_serializeOpModifyAccount) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1623	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1624) {
1625	request, ok := in.Request.(*smithyhttp.Request)
1626	if !ok {
1627		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1628	}
1629
1630	input, ok := in.Parameters.(*ModifyAccountInput)
1631	_ = input
1632	if !ok {
1633		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1634	}
1635
1636	request.Request.URL.Path = "/"
1637	request.Request.Method = "POST"
1638	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1639	if err != nil {
1640		return out, metadata, &smithy.SerializationError{Err: err}
1641	}
1642	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1643	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.ModifyAccount")
1644
1645	jsonEncoder := smithyjson.NewEncoder()
1646	if err := awsAwsjson11_serializeOpDocumentModifyAccountInput(input, jsonEncoder.Value); err != nil {
1647		return out, metadata, &smithy.SerializationError{Err: err}
1648	}
1649
1650	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1651		return out, metadata, &smithy.SerializationError{Err: err}
1652	}
1653
1654	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1655		return out, metadata, &smithy.SerializationError{Err: err}
1656	}
1657	in.Request = request
1658
1659	return next.HandleSerialize(ctx, in)
1660}
1661
1662type awsAwsjson11_serializeOpModifyClientProperties struct {
1663}
1664
1665func (*awsAwsjson11_serializeOpModifyClientProperties) ID() string {
1666	return "OperationSerializer"
1667}
1668
1669func (m *awsAwsjson11_serializeOpModifyClientProperties) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1670	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1671) {
1672	request, ok := in.Request.(*smithyhttp.Request)
1673	if !ok {
1674		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1675	}
1676
1677	input, ok := in.Parameters.(*ModifyClientPropertiesInput)
1678	_ = input
1679	if !ok {
1680		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1681	}
1682
1683	request.Request.URL.Path = "/"
1684	request.Request.Method = "POST"
1685	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1686	if err != nil {
1687		return out, metadata, &smithy.SerializationError{Err: err}
1688	}
1689	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1690	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.ModifyClientProperties")
1691
1692	jsonEncoder := smithyjson.NewEncoder()
1693	if err := awsAwsjson11_serializeOpDocumentModifyClientPropertiesInput(input, jsonEncoder.Value); err != nil {
1694		return out, metadata, &smithy.SerializationError{Err: err}
1695	}
1696
1697	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1698		return out, metadata, &smithy.SerializationError{Err: err}
1699	}
1700
1701	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1702		return out, metadata, &smithy.SerializationError{Err: err}
1703	}
1704	in.Request = request
1705
1706	return next.HandleSerialize(ctx, in)
1707}
1708
1709type awsAwsjson11_serializeOpModifySelfservicePermissions struct {
1710}
1711
1712func (*awsAwsjson11_serializeOpModifySelfservicePermissions) ID() string {
1713	return "OperationSerializer"
1714}
1715
1716func (m *awsAwsjson11_serializeOpModifySelfservicePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1717	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1718) {
1719	request, ok := in.Request.(*smithyhttp.Request)
1720	if !ok {
1721		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1722	}
1723
1724	input, ok := in.Parameters.(*ModifySelfservicePermissionsInput)
1725	_ = input
1726	if !ok {
1727		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1728	}
1729
1730	request.Request.URL.Path = "/"
1731	request.Request.Method = "POST"
1732	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1733	if err != nil {
1734		return out, metadata, &smithy.SerializationError{Err: err}
1735	}
1736	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1737	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.ModifySelfservicePermissions")
1738
1739	jsonEncoder := smithyjson.NewEncoder()
1740	if err := awsAwsjson11_serializeOpDocumentModifySelfservicePermissionsInput(input, jsonEncoder.Value); err != nil {
1741		return out, metadata, &smithy.SerializationError{Err: err}
1742	}
1743
1744	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1745		return out, metadata, &smithy.SerializationError{Err: err}
1746	}
1747
1748	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1749		return out, metadata, &smithy.SerializationError{Err: err}
1750	}
1751	in.Request = request
1752
1753	return next.HandleSerialize(ctx, in)
1754}
1755
1756type awsAwsjson11_serializeOpModifyWorkspaceAccessProperties struct {
1757}
1758
1759func (*awsAwsjson11_serializeOpModifyWorkspaceAccessProperties) ID() string {
1760	return "OperationSerializer"
1761}
1762
1763func (m *awsAwsjson11_serializeOpModifyWorkspaceAccessProperties) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1764	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1765) {
1766	request, ok := in.Request.(*smithyhttp.Request)
1767	if !ok {
1768		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1769	}
1770
1771	input, ok := in.Parameters.(*ModifyWorkspaceAccessPropertiesInput)
1772	_ = input
1773	if !ok {
1774		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1775	}
1776
1777	request.Request.URL.Path = "/"
1778	request.Request.Method = "POST"
1779	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1780	if err != nil {
1781		return out, metadata, &smithy.SerializationError{Err: err}
1782	}
1783	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1784	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.ModifyWorkspaceAccessProperties")
1785
1786	jsonEncoder := smithyjson.NewEncoder()
1787	if err := awsAwsjson11_serializeOpDocumentModifyWorkspaceAccessPropertiesInput(input, jsonEncoder.Value); err != nil {
1788		return out, metadata, &smithy.SerializationError{Err: err}
1789	}
1790
1791	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1792		return out, metadata, &smithy.SerializationError{Err: err}
1793	}
1794
1795	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1796		return out, metadata, &smithy.SerializationError{Err: err}
1797	}
1798	in.Request = request
1799
1800	return next.HandleSerialize(ctx, in)
1801}
1802
1803type awsAwsjson11_serializeOpModifyWorkspaceCreationProperties struct {
1804}
1805
1806func (*awsAwsjson11_serializeOpModifyWorkspaceCreationProperties) ID() string {
1807	return "OperationSerializer"
1808}
1809
1810func (m *awsAwsjson11_serializeOpModifyWorkspaceCreationProperties) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1811	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1812) {
1813	request, ok := in.Request.(*smithyhttp.Request)
1814	if !ok {
1815		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1816	}
1817
1818	input, ok := in.Parameters.(*ModifyWorkspaceCreationPropertiesInput)
1819	_ = input
1820	if !ok {
1821		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1822	}
1823
1824	request.Request.URL.Path = "/"
1825	request.Request.Method = "POST"
1826	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1827	if err != nil {
1828		return out, metadata, &smithy.SerializationError{Err: err}
1829	}
1830	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1831	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.ModifyWorkspaceCreationProperties")
1832
1833	jsonEncoder := smithyjson.NewEncoder()
1834	if err := awsAwsjson11_serializeOpDocumentModifyWorkspaceCreationPropertiesInput(input, jsonEncoder.Value); err != nil {
1835		return out, metadata, &smithy.SerializationError{Err: err}
1836	}
1837
1838	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1839		return out, metadata, &smithy.SerializationError{Err: err}
1840	}
1841
1842	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1843		return out, metadata, &smithy.SerializationError{Err: err}
1844	}
1845	in.Request = request
1846
1847	return next.HandleSerialize(ctx, in)
1848}
1849
1850type awsAwsjson11_serializeOpModifyWorkspaceProperties struct {
1851}
1852
1853func (*awsAwsjson11_serializeOpModifyWorkspaceProperties) ID() string {
1854	return "OperationSerializer"
1855}
1856
1857func (m *awsAwsjson11_serializeOpModifyWorkspaceProperties) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1858	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1859) {
1860	request, ok := in.Request.(*smithyhttp.Request)
1861	if !ok {
1862		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1863	}
1864
1865	input, ok := in.Parameters.(*ModifyWorkspacePropertiesInput)
1866	_ = input
1867	if !ok {
1868		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1869	}
1870
1871	request.Request.URL.Path = "/"
1872	request.Request.Method = "POST"
1873	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1874	if err != nil {
1875		return out, metadata, &smithy.SerializationError{Err: err}
1876	}
1877	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1878	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.ModifyWorkspaceProperties")
1879
1880	jsonEncoder := smithyjson.NewEncoder()
1881	if err := awsAwsjson11_serializeOpDocumentModifyWorkspacePropertiesInput(input, jsonEncoder.Value); err != nil {
1882		return out, metadata, &smithy.SerializationError{Err: err}
1883	}
1884
1885	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1886		return out, metadata, &smithy.SerializationError{Err: err}
1887	}
1888
1889	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1890		return out, metadata, &smithy.SerializationError{Err: err}
1891	}
1892	in.Request = request
1893
1894	return next.HandleSerialize(ctx, in)
1895}
1896
1897type awsAwsjson11_serializeOpModifyWorkspaceState struct {
1898}
1899
1900func (*awsAwsjson11_serializeOpModifyWorkspaceState) ID() string {
1901	return "OperationSerializer"
1902}
1903
1904func (m *awsAwsjson11_serializeOpModifyWorkspaceState) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1905	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1906) {
1907	request, ok := in.Request.(*smithyhttp.Request)
1908	if !ok {
1909		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1910	}
1911
1912	input, ok := in.Parameters.(*ModifyWorkspaceStateInput)
1913	_ = input
1914	if !ok {
1915		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1916	}
1917
1918	request.Request.URL.Path = "/"
1919	request.Request.Method = "POST"
1920	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1921	if err != nil {
1922		return out, metadata, &smithy.SerializationError{Err: err}
1923	}
1924	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1925	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.ModifyWorkspaceState")
1926
1927	jsonEncoder := smithyjson.NewEncoder()
1928	if err := awsAwsjson11_serializeOpDocumentModifyWorkspaceStateInput(input, jsonEncoder.Value); err != nil {
1929		return out, metadata, &smithy.SerializationError{Err: err}
1930	}
1931
1932	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1933		return out, metadata, &smithy.SerializationError{Err: err}
1934	}
1935
1936	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1937		return out, metadata, &smithy.SerializationError{Err: err}
1938	}
1939	in.Request = request
1940
1941	return next.HandleSerialize(ctx, in)
1942}
1943
1944type awsAwsjson11_serializeOpRebootWorkspaces struct {
1945}
1946
1947func (*awsAwsjson11_serializeOpRebootWorkspaces) ID() string {
1948	return "OperationSerializer"
1949}
1950
1951func (m *awsAwsjson11_serializeOpRebootWorkspaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1952	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1953) {
1954	request, ok := in.Request.(*smithyhttp.Request)
1955	if !ok {
1956		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1957	}
1958
1959	input, ok := in.Parameters.(*RebootWorkspacesInput)
1960	_ = input
1961	if !ok {
1962		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1963	}
1964
1965	request.Request.URL.Path = "/"
1966	request.Request.Method = "POST"
1967	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1968	if err != nil {
1969		return out, metadata, &smithy.SerializationError{Err: err}
1970	}
1971	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
1972	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.RebootWorkspaces")
1973
1974	jsonEncoder := smithyjson.NewEncoder()
1975	if err := awsAwsjson11_serializeOpDocumentRebootWorkspacesInput(input, jsonEncoder.Value); err != nil {
1976		return out, metadata, &smithy.SerializationError{Err: err}
1977	}
1978
1979	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1980		return out, metadata, &smithy.SerializationError{Err: err}
1981	}
1982
1983	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
1984		return out, metadata, &smithy.SerializationError{Err: err}
1985	}
1986	in.Request = request
1987
1988	return next.HandleSerialize(ctx, in)
1989}
1990
1991type awsAwsjson11_serializeOpRebuildWorkspaces struct {
1992}
1993
1994func (*awsAwsjson11_serializeOpRebuildWorkspaces) ID() string {
1995	return "OperationSerializer"
1996}
1997
1998func (m *awsAwsjson11_serializeOpRebuildWorkspaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1999	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2000) {
2001	request, ok := in.Request.(*smithyhttp.Request)
2002	if !ok {
2003		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2004	}
2005
2006	input, ok := in.Parameters.(*RebuildWorkspacesInput)
2007	_ = input
2008	if !ok {
2009		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2010	}
2011
2012	request.Request.URL.Path = "/"
2013	request.Request.Method = "POST"
2014	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2015	if err != nil {
2016		return out, metadata, &smithy.SerializationError{Err: err}
2017	}
2018	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2019	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.RebuildWorkspaces")
2020
2021	jsonEncoder := smithyjson.NewEncoder()
2022	if err := awsAwsjson11_serializeOpDocumentRebuildWorkspacesInput(input, jsonEncoder.Value); err != nil {
2023		return out, metadata, &smithy.SerializationError{Err: err}
2024	}
2025
2026	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2027		return out, metadata, &smithy.SerializationError{Err: err}
2028	}
2029
2030	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2031		return out, metadata, &smithy.SerializationError{Err: err}
2032	}
2033	in.Request = request
2034
2035	return next.HandleSerialize(ctx, in)
2036}
2037
2038type awsAwsjson11_serializeOpRegisterWorkspaceDirectory struct {
2039}
2040
2041func (*awsAwsjson11_serializeOpRegisterWorkspaceDirectory) ID() string {
2042	return "OperationSerializer"
2043}
2044
2045func (m *awsAwsjson11_serializeOpRegisterWorkspaceDirectory) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2046	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2047) {
2048	request, ok := in.Request.(*smithyhttp.Request)
2049	if !ok {
2050		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2051	}
2052
2053	input, ok := in.Parameters.(*RegisterWorkspaceDirectoryInput)
2054	_ = input
2055	if !ok {
2056		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2057	}
2058
2059	request.Request.URL.Path = "/"
2060	request.Request.Method = "POST"
2061	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2062	if err != nil {
2063		return out, metadata, &smithy.SerializationError{Err: err}
2064	}
2065	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2066	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.RegisterWorkspaceDirectory")
2067
2068	jsonEncoder := smithyjson.NewEncoder()
2069	if err := awsAwsjson11_serializeOpDocumentRegisterWorkspaceDirectoryInput(input, jsonEncoder.Value); err != nil {
2070		return out, metadata, &smithy.SerializationError{Err: err}
2071	}
2072
2073	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2074		return out, metadata, &smithy.SerializationError{Err: err}
2075	}
2076
2077	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2078		return out, metadata, &smithy.SerializationError{Err: err}
2079	}
2080	in.Request = request
2081
2082	return next.HandleSerialize(ctx, in)
2083}
2084
2085type awsAwsjson11_serializeOpRestoreWorkspace struct {
2086}
2087
2088func (*awsAwsjson11_serializeOpRestoreWorkspace) ID() string {
2089	return "OperationSerializer"
2090}
2091
2092func (m *awsAwsjson11_serializeOpRestoreWorkspace) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2093	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2094) {
2095	request, ok := in.Request.(*smithyhttp.Request)
2096	if !ok {
2097		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2098	}
2099
2100	input, ok := in.Parameters.(*RestoreWorkspaceInput)
2101	_ = input
2102	if !ok {
2103		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2104	}
2105
2106	request.Request.URL.Path = "/"
2107	request.Request.Method = "POST"
2108	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2109	if err != nil {
2110		return out, metadata, &smithy.SerializationError{Err: err}
2111	}
2112	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2113	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.RestoreWorkspace")
2114
2115	jsonEncoder := smithyjson.NewEncoder()
2116	if err := awsAwsjson11_serializeOpDocumentRestoreWorkspaceInput(input, jsonEncoder.Value); err != nil {
2117		return out, metadata, &smithy.SerializationError{Err: err}
2118	}
2119
2120	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2121		return out, metadata, &smithy.SerializationError{Err: err}
2122	}
2123
2124	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2125		return out, metadata, &smithy.SerializationError{Err: err}
2126	}
2127	in.Request = request
2128
2129	return next.HandleSerialize(ctx, in)
2130}
2131
2132type awsAwsjson11_serializeOpRevokeIpRules struct {
2133}
2134
2135func (*awsAwsjson11_serializeOpRevokeIpRules) ID() string {
2136	return "OperationSerializer"
2137}
2138
2139func (m *awsAwsjson11_serializeOpRevokeIpRules) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2140	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2141) {
2142	request, ok := in.Request.(*smithyhttp.Request)
2143	if !ok {
2144		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2145	}
2146
2147	input, ok := in.Parameters.(*RevokeIpRulesInput)
2148	_ = input
2149	if !ok {
2150		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2151	}
2152
2153	request.Request.URL.Path = "/"
2154	request.Request.Method = "POST"
2155	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2156	if err != nil {
2157		return out, metadata, &smithy.SerializationError{Err: err}
2158	}
2159	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2160	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.RevokeIpRules")
2161
2162	jsonEncoder := smithyjson.NewEncoder()
2163	if err := awsAwsjson11_serializeOpDocumentRevokeIpRulesInput(input, jsonEncoder.Value); err != nil {
2164		return out, metadata, &smithy.SerializationError{Err: err}
2165	}
2166
2167	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2168		return out, metadata, &smithy.SerializationError{Err: err}
2169	}
2170
2171	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2172		return out, metadata, &smithy.SerializationError{Err: err}
2173	}
2174	in.Request = request
2175
2176	return next.HandleSerialize(ctx, in)
2177}
2178
2179type awsAwsjson11_serializeOpStartWorkspaces struct {
2180}
2181
2182func (*awsAwsjson11_serializeOpStartWorkspaces) ID() string {
2183	return "OperationSerializer"
2184}
2185
2186func (m *awsAwsjson11_serializeOpStartWorkspaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2187	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2188) {
2189	request, ok := in.Request.(*smithyhttp.Request)
2190	if !ok {
2191		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2192	}
2193
2194	input, ok := in.Parameters.(*StartWorkspacesInput)
2195	_ = input
2196	if !ok {
2197		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2198	}
2199
2200	request.Request.URL.Path = "/"
2201	request.Request.Method = "POST"
2202	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2203	if err != nil {
2204		return out, metadata, &smithy.SerializationError{Err: err}
2205	}
2206	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2207	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.StartWorkspaces")
2208
2209	jsonEncoder := smithyjson.NewEncoder()
2210	if err := awsAwsjson11_serializeOpDocumentStartWorkspacesInput(input, jsonEncoder.Value); err != nil {
2211		return out, metadata, &smithy.SerializationError{Err: err}
2212	}
2213
2214	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2215		return out, metadata, &smithy.SerializationError{Err: err}
2216	}
2217
2218	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2219		return out, metadata, &smithy.SerializationError{Err: err}
2220	}
2221	in.Request = request
2222
2223	return next.HandleSerialize(ctx, in)
2224}
2225
2226type awsAwsjson11_serializeOpStopWorkspaces struct {
2227}
2228
2229func (*awsAwsjson11_serializeOpStopWorkspaces) ID() string {
2230	return "OperationSerializer"
2231}
2232
2233func (m *awsAwsjson11_serializeOpStopWorkspaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2234	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2235) {
2236	request, ok := in.Request.(*smithyhttp.Request)
2237	if !ok {
2238		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2239	}
2240
2241	input, ok := in.Parameters.(*StopWorkspacesInput)
2242	_ = input
2243	if !ok {
2244		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2245	}
2246
2247	request.Request.URL.Path = "/"
2248	request.Request.Method = "POST"
2249	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2250	if err != nil {
2251		return out, metadata, &smithy.SerializationError{Err: err}
2252	}
2253	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2254	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.StopWorkspaces")
2255
2256	jsonEncoder := smithyjson.NewEncoder()
2257	if err := awsAwsjson11_serializeOpDocumentStopWorkspacesInput(input, jsonEncoder.Value); err != nil {
2258		return out, metadata, &smithy.SerializationError{Err: err}
2259	}
2260
2261	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2262		return out, metadata, &smithy.SerializationError{Err: err}
2263	}
2264
2265	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2266		return out, metadata, &smithy.SerializationError{Err: err}
2267	}
2268	in.Request = request
2269
2270	return next.HandleSerialize(ctx, in)
2271}
2272
2273type awsAwsjson11_serializeOpTerminateWorkspaces struct {
2274}
2275
2276func (*awsAwsjson11_serializeOpTerminateWorkspaces) ID() string {
2277	return "OperationSerializer"
2278}
2279
2280func (m *awsAwsjson11_serializeOpTerminateWorkspaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2281	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2282) {
2283	request, ok := in.Request.(*smithyhttp.Request)
2284	if !ok {
2285		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2286	}
2287
2288	input, ok := in.Parameters.(*TerminateWorkspacesInput)
2289	_ = input
2290	if !ok {
2291		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2292	}
2293
2294	request.Request.URL.Path = "/"
2295	request.Request.Method = "POST"
2296	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2297	if err != nil {
2298		return out, metadata, &smithy.SerializationError{Err: err}
2299	}
2300	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2301	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.TerminateWorkspaces")
2302
2303	jsonEncoder := smithyjson.NewEncoder()
2304	if err := awsAwsjson11_serializeOpDocumentTerminateWorkspacesInput(input, jsonEncoder.Value); err != nil {
2305		return out, metadata, &smithy.SerializationError{Err: err}
2306	}
2307
2308	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2309		return out, metadata, &smithy.SerializationError{Err: err}
2310	}
2311
2312	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2313		return out, metadata, &smithy.SerializationError{Err: err}
2314	}
2315	in.Request = request
2316
2317	return next.HandleSerialize(ctx, in)
2318}
2319
2320type awsAwsjson11_serializeOpUpdateConnectionAliasPermission struct {
2321}
2322
2323func (*awsAwsjson11_serializeOpUpdateConnectionAliasPermission) ID() string {
2324	return "OperationSerializer"
2325}
2326
2327func (m *awsAwsjson11_serializeOpUpdateConnectionAliasPermission) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2328	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2329) {
2330	request, ok := in.Request.(*smithyhttp.Request)
2331	if !ok {
2332		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2333	}
2334
2335	input, ok := in.Parameters.(*UpdateConnectionAliasPermissionInput)
2336	_ = input
2337	if !ok {
2338		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2339	}
2340
2341	request.Request.URL.Path = "/"
2342	request.Request.Method = "POST"
2343	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2344	if err != nil {
2345		return out, metadata, &smithy.SerializationError{Err: err}
2346	}
2347	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2348	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.UpdateConnectionAliasPermission")
2349
2350	jsonEncoder := smithyjson.NewEncoder()
2351	if err := awsAwsjson11_serializeOpDocumentUpdateConnectionAliasPermissionInput(input, jsonEncoder.Value); err != nil {
2352		return out, metadata, &smithy.SerializationError{Err: err}
2353	}
2354
2355	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2356		return out, metadata, &smithy.SerializationError{Err: err}
2357	}
2358
2359	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2360		return out, metadata, &smithy.SerializationError{Err: err}
2361	}
2362	in.Request = request
2363
2364	return next.HandleSerialize(ctx, in)
2365}
2366
2367type awsAwsjson11_serializeOpUpdateRulesOfIpGroup struct {
2368}
2369
2370func (*awsAwsjson11_serializeOpUpdateRulesOfIpGroup) ID() string {
2371	return "OperationSerializer"
2372}
2373
2374func (m *awsAwsjson11_serializeOpUpdateRulesOfIpGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2375	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2376) {
2377	request, ok := in.Request.(*smithyhttp.Request)
2378	if !ok {
2379		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2380	}
2381
2382	input, ok := in.Parameters.(*UpdateRulesOfIpGroupInput)
2383	_ = input
2384	if !ok {
2385		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2386	}
2387
2388	request.Request.URL.Path = "/"
2389	request.Request.Method = "POST"
2390	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2391	if err != nil {
2392		return out, metadata, &smithy.SerializationError{Err: err}
2393	}
2394	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2395	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.UpdateRulesOfIpGroup")
2396
2397	jsonEncoder := smithyjson.NewEncoder()
2398	if err := awsAwsjson11_serializeOpDocumentUpdateRulesOfIpGroupInput(input, jsonEncoder.Value); err != nil {
2399		return out, metadata, &smithy.SerializationError{Err: err}
2400	}
2401
2402	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2403		return out, metadata, &smithy.SerializationError{Err: err}
2404	}
2405
2406	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2407		return out, metadata, &smithy.SerializationError{Err: err}
2408	}
2409	in.Request = request
2410
2411	return next.HandleSerialize(ctx, in)
2412}
2413
2414type awsAwsjson11_serializeOpUpdateWorkspaceBundle struct {
2415}
2416
2417func (*awsAwsjson11_serializeOpUpdateWorkspaceBundle) ID() string {
2418	return "OperationSerializer"
2419}
2420
2421func (m *awsAwsjson11_serializeOpUpdateWorkspaceBundle) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2422	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2423) {
2424	request, ok := in.Request.(*smithyhttp.Request)
2425	if !ok {
2426		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2427	}
2428
2429	input, ok := in.Parameters.(*UpdateWorkspaceBundleInput)
2430	_ = input
2431	if !ok {
2432		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2433	}
2434
2435	request.Request.URL.Path = "/"
2436	request.Request.Method = "POST"
2437	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2438	if err != nil {
2439		return out, metadata, &smithy.SerializationError{Err: err}
2440	}
2441	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2442	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.UpdateWorkspaceBundle")
2443
2444	jsonEncoder := smithyjson.NewEncoder()
2445	if err := awsAwsjson11_serializeOpDocumentUpdateWorkspaceBundleInput(input, jsonEncoder.Value); err != nil {
2446		return out, metadata, &smithy.SerializationError{Err: err}
2447	}
2448
2449	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2450		return out, metadata, &smithy.SerializationError{Err: err}
2451	}
2452
2453	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2454		return out, metadata, &smithy.SerializationError{Err: err}
2455	}
2456	in.Request = request
2457
2458	return next.HandleSerialize(ctx, in)
2459}
2460
2461type awsAwsjson11_serializeOpUpdateWorkspaceImagePermission struct {
2462}
2463
2464func (*awsAwsjson11_serializeOpUpdateWorkspaceImagePermission) ID() string {
2465	return "OperationSerializer"
2466}
2467
2468func (m *awsAwsjson11_serializeOpUpdateWorkspaceImagePermission) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2469	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2470) {
2471	request, ok := in.Request.(*smithyhttp.Request)
2472	if !ok {
2473		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2474	}
2475
2476	input, ok := in.Parameters.(*UpdateWorkspaceImagePermissionInput)
2477	_ = input
2478	if !ok {
2479		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2480	}
2481
2482	request.Request.URL.Path = "/"
2483	request.Request.Method = "POST"
2484	httpBindingEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2485	if err != nil {
2486		return out, metadata, &smithy.SerializationError{Err: err}
2487	}
2488	httpBindingEncoder.SetHeader("Content-Type").String("application/x-amz-json-1.1")
2489	httpBindingEncoder.SetHeader("X-Amz-Target").String("WorkspacesService.UpdateWorkspaceImagePermission")
2490
2491	jsonEncoder := smithyjson.NewEncoder()
2492	if err := awsAwsjson11_serializeOpDocumentUpdateWorkspaceImagePermissionInput(input, jsonEncoder.Value); err != nil {
2493		return out, metadata, &smithy.SerializationError{Err: err}
2494	}
2495
2496	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
2497		return out, metadata, &smithy.SerializationError{Err: err}
2498	}
2499
2500	if request.Request, err = httpBindingEncoder.Encode(request.Request); err != nil {
2501		return out, metadata, &smithy.SerializationError{Err: err}
2502	}
2503	in.Request = request
2504
2505	return next.HandleSerialize(ctx, in)
2506}
2507func awsAwsjson11_serializeDocumentApplicationList(v []types.Application, value smithyjson.Value) error {
2508	array := value.Array()
2509	defer array.Close()
2510
2511	for i := range v {
2512		av := array.Value()
2513		av.String(string(v[i]))
2514	}
2515	return nil
2516}
2517
2518func awsAwsjson11_serializeDocumentBundleIdList(v []string, value smithyjson.Value) error {
2519	array := value.Array()
2520	defer array.Close()
2521
2522	for i := range v {
2523		av := array.Value()
2524		av.String(v[i])
2525	}
2526	return nil
2527}
2528
2529func awsAwsjson11_serializeDocumentClientProperties(v *types.ClientProperties, value smithyjson.Value) error {
2530	object := value.Object()
2531	defer object.Close()
2532
2533	if len(v.ReconnectEnabled) > 0 {
2534		ok := object.Key("ReconnectEnabled")
2535		ok.String(string(v.ReconnectEnabled))
2536	}
2537
2538	return nil
2539}
2540
2541func awsAwsjson11_serializeDocumentComputeType(v *types.ComputeType, value smithyjson.Value) error {
2542	object := value.Object()
2543	defer object.Close()
2544
2545	if len(v.Name) > 0 {
2546		ok := object.Key("Name")
2547		ok.String(string(v.Name))
2548	}
2549
2550	return nil
2551}
2552
2553func awsAwsjson11_serializeDocumentConnectionAliasIdList(v []string, value smithyjson.Value) error {
2554	array := value.Array()
2555	defer array.Close()
2556
2557	for i := range v {
2558		av := array.Value()
2559		av.String(v[i])
2560	}
2561	return nil
2562}
2563
2564func awsAwsjson11_serializeDocumentConnectionAliasPermission(v *types.ConnectionAliasPermission, value smithyjson.Value) error {
2565	object := value.Object()
2566	defer object.Close()
2567
2568	if v.AllowAssociation != nil {
2569		ok := object.Key("AllowAssociation")
2570		ok.Boolean(*v.AllowAssociation)
2571	}
2572
2573	if v.SharedAccountId != nil {
2574		ok := object.Key("SharedAccountId")
2575		ok.String(*v.SharedAccountId)
2576	}
2577
2578	return nil
2579}
2580
2581func awsAwsjson11_serializeDocumentDirectoryIdList(v []string, value smithyjson.Value) error {
2582	array := value.Array()
2583	defer array.Close()
2584
2585	for i := range v {
2586		av := array.Value()
2587		av.String(v[i])
2588	}
2589	return nil
2590}
2591
2592func awsAwsjson11_serializeDocumentIpGroupIdList(v []string, value smithyjson.Value) error {
2593	array := value.Array()
2594	defer array.Close()
2595
2596	for i := range v {
2597		av := array.Value()
2598		av.String(v[i])
2599	}
2600	return nil
2601}
2602
2603func awsAwsjson11_serializeDocumentIpRevokedRuleList(v []string, value smithyjson.Value) error {
2604	array := value.Array()
2605	defer array.Close()
2606
2607	for i := range v {
2608		av := array.Value()
2609		av.String(v[i])
2610	}
2611	return nil
2612}
2613
2614func awsAwsjson11_serializeDocumentIpRuleItem(v *types.IpRuleItem, value smithyjson.Value) error {
2615	object := value.Object()
2616	defer object.Close()
2617
2618	if v.IpRule != nil {
2619		ok := object.Key("ipRule")
2620		ok.String(*v.IpRule)
2621	}
2622
2623	if v.RuleDesc != nil {
2624		ok := object.Key("ruleDesc")
2625		ok.String(*v.RuleDesc)
2626	}
2627
2628	return nil
2629}
2630
2631func awsAwsjson11_serializeDocumentIpRuleList(v []types.IpRuleItem, value smithyjson.Value) error {
2632	array := value.Array()
2633	defer array.Close()
2634
2635	for i := range v {
2636		av := array.Value()
2637		if err := awsAwsjson11_serializeDocumentIpRuleItem(&v[i], av); err != nil {
2638			return err
2639		}
2640	}
2641	return nil
2642}
2643
2644func awsAwsjson11_serializeDocumentRebootRequest(v *types.RebootRequest, value smithyjson.Value) error {
2645	object := value.Object()
2646	defer object.Close()
2647
2648	if v.WorkspaceId != nil {
2649		ok := object.Key("WorkspaceId")
2650		ok.String(*v.WorkspaceId)
2651	}
2652
2653	return nil
2654}
2655
2656func awsAwsjson11_serializeDocumentRebootWorkspaceRequests(v []types.RebootRequest, value smithyjson.Value) error {
2657	array := value.Array()
2658	defer array.Close()
2659
2660	for i := range v {
2661		av := array.Value()
2662		if err := awsAwsjson11_serializeDocumentRebootRequest(&v[i], av); err != nil {
2663			return err
2664		}
2665	}
2666	return nil
2667}
2668
2669func awsAwsjson11_serializeDocumentRebuildRequest(v *types.RebuildRequest, value smithyjson.Value) error {
2670	object := value.Object()
2671	defer object.Close()
2672
2673	if v.WorkspaceId != nil {
2674		ok := object.Key("WorkspaceId")
2675		ok.String(*v.WorkspaceId)
2676	}
2677
2678	return nil
2679}
2680
2681func awsAwsjson11_serializeDocumentRebuildWorkspaceRequests(v []types.RebuildRequest, value smithyjson.Value) error {
2682	array := value.Array()
2683	defer array.Close()
2684
2685	for i := range v {
2686		av := array.Value()
2687		if err := awsAwsjson11_serializeDocumentRebuildRequest(&v[i], av); err != nil {
2688			return err
2689		}
2690	}
2691	return nil
2692}
2693
2694func awsAwsjson11_serializeDocumentResourceIdList(v []string, value smithyjson.Value) error {
2695	array := value.Array()
2696	defer array.Close()
2697
2698	for i := range v {
2699		av := array.Value()
2700		av.String(v[i])
2701	}
2702	return nil
2703}
2704
2705func awsAwsjson11_serializeDocumentRootStorage(v *types.RootStorage, value smithyjson.Value) error {
2706	object := value.Object()
2707	defer object.Close()
2708
2709	if v.Capacity != nil {
2710		ok := object.Key("Capacity")
2711		ok.String(*v.Capacity)
2712	}
2713
2714	return nil
2715}
2716
2717func awsAwsjson11_serializeDocumentSelfservicePermissions(v *types.SelfservicePermissions, value smithyjson.Value) error {
2718	object := value.Object()
2719	defer object.Close()
2720
2721	if len(v.ChangeComputeType) > 0 {
2722		ok := object.Key("ChangeComputeType")
2723		ok.String(string(v.ChangeComputeType))
2724	}
2725
2726	if len(v.IncreaseVolumeSize) > 0 {
2727		ok := object.Key("IncreaseVolumeSize")
2728		ok.String(string(v.IncreaseVolumeSize))
2729	}
2730
2731	if len(v.RebuildWorkspace) > 0 {
2732		ok := object.Key("RebuildWorkspace")
2733		ok.String(string(v.RebuildWorkspace))
2734	}
2735
2736	if len(v.RestartWorkspace) > 0 {
2737		ok := object.Key("RestartWorkspace")
2738		ok.String(string(v.RestartWorkspace))
2739	}
2740
2741	if len(v.SwitchRunningMode) > 0 {
2742		ok := object.Key("SwitchRunningMode")
2743		ok.String(string(v.SwitchRunningMode))
2744	}
2745
2746	return nil
2747}
2748
2749func awsAwsjson11_serializeDocumentStartRequest(v *types.StartRequest, value smithyjson.Value) error {
2750	object := value.Object()
2751	defer object.Close()
2752
2753	if v.WorkspaceId != nil {
2754		ok := object.Key("WorkspaceId")
2755		ok.String(*v.WorkspaceId)
2756	}
2757
2758	return nil
2759}
2760
2761func awsAwsjson11_serializeDocumentStartWorkspaceRequests(v []types.StartRequest, value smithyjson.Value) error {
2762	array := value.Array()
2763	defer array.Close()
2764
2765	for i := range v {
2766		av := array.Value()
2767		if err := awsAwsjson11_serializeDocumentStartRequest(&v[i], av); err != nil {
2768			return err
2769		}
2770	}
2771	return nil
2772}
2773
2774func awsAwsjson11_serializeDocumentStopRequest(v *types.StopRequest, value smithyjson.Value) error {
2775	object := value.Object()
2776	defer object.Close()
2777
2778	if v.WorkspaceId != nil {
2779		ok := object.Key("WorkspaceId")
2780		ok.String(*v.WorkspaceId)
2781	}
2782
2783	return nil
2784}
2785
2786func awsAwsjson11_serializeDocumentStopWorkspaceRequests(v []types.StopRequest, value smithyjson.Value) error {
2787	array := value.Array()
2788	defer array.Close()
2789
2790	for i := range v {
2791		av := array.Value()
2792		if err := awsAwsjson11_serializeDocumentStopRequest(&v[i], av); err != nil {
2793			return err
2794		}
2795	}
2796	return nil
2797}
2798
2799func awsAwsjson11_serializeDocumentSubnetIds(v []string, value smithyjson.Value) error {
2800	array := value.Array()
2801	defer array.Close()
2802
2803	for i := range v {
2804		av := array.Value()
2805		av.String(v[i])
2806	}
2807	return nil
2808}
2809
2810func awsAwsjson11_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
2811	object := value.Object()
2812	defer object.Close()
2813
2814	if v.Key != nil {
2815		ok := object.Key("Key")
2816		ok.String(*v.Key)
2817	}
2818
2819	if v.Value != nil {
2820		ok := object.Key("Value")
2821		ok.String(*v.Value)
2822	}
2823
2824	return nil
2825}
2826
2827func awsAwsjson11_serializeDocumentTagKeyList(v []string, value smithyjson.Value) error {
2828	array := value.Array()
2829	defer array.Close()
2830
2831	for i := range v {
2832		av := array.Value()
2833		av.String(v[i])
2834	}
2835	return nil
2836}
2837
2838func awsAwsjson11_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
2839	array := value.Array()
2840	defer array.Close()
2841
2842	for i := range v {
2843		av := array.Value()
2844		if err := awsAwsjson11_serializeDocumentTag(&v[i], av); err != nil {
2845			return err
2846		}
2847	}
2848	return nil
2849}
2850
2851func awsAwsjson11_serializeDocumentTerminateRequest(v *types.TerminateRequest, value smithyjson.Value) error {
2852	object := value.Object()
2853	defer object.Close()
2854
2855	if v.WorkspaceId != nil {
2856		ok := object.Key("WorkspaceId")
2857		ok.String(*v.WorkspaceId)
2858	}
2859
2860	return nil
2861}
2862
2863func awsAwsjson11_serializeDocumentTerminateWorkspaceRequests(v []types.TerminateRequest, value smithyjson.Value) error {
2864	array := value.Array()
2865	defer array.Close()
2866
2867	for i := range v {
2868		av := array.Value()
2869		if err := awsAwsjson11_serializeDocumentTerminateRequest(&v[i], av); err != nil {
2870			return err
2871		}
2872	}
2873	return nil
2874}
2875
2876func awsAwsjson11_serializeDocumentUserStorage(v *types.UserStorage, value smithyjson.Value) error {
2877	object := value.Object()
2878	defer object.Close()
2879
2880	if v.Capacity != nil {
2881		ok := object.Key("Capacity")
2882		ok.String(*v.Capacity)
2883	}
2884
2885	return nil
2886}
2887
2888func awsAwsjson11_serializeDocumentWorkspaceAccessProperties(v *types.WorkspaceAccessProperties, value smithyjson.Value) error {
2889	object := value.Object()
2890	defer object.Close()
2891
2892	if len(v.DeviceTypeAndroid) > 0 {
2893		ok := object.Key("DeviceTypeAndroid")
2894		ok.String(string(v.DeviceTypeAndroid))
2895	}
2896
2897	if len(v.DeviceTypeChromeOs) > 0 {
2898		ok := object.Key("DeviceTypeChromeOs")
2899		ok.String(string(v.DeviceTypeChromeOs))
2900	}
2901
2902	if len(v.DeviceTypeIos) > 0 {
2903		ok := object.Key("DeviceTypeIos")
2904		ok.String(string(v.DeviceTypeIos))
2905	}
2906
2907	if len(v.DeviceTypeOsx) > 0 {
2908		ok := object.Key("DeviceTypeOsx")
2909		ok.String(string(v.DeviceTypeOsx))
2910	}
2911
2912	if len(v.DeviceTypeWeb) > 0 {
2913		ok := object.Key("DeviceTypeWeb")
2914		ok.String(string(v.DeviceTypeWeb))
2915	}
2916
2917	if len(v.DeviceTypeWindows) > 0 {
2918		ok := object.Key("DeviceTypeWindows")
2919		ok.String(string(v.DeviceTypeWindows))
2920	}
2921
2922	if len(v.DeviceTypeZeroClient) > 0 {
2923		ok := object.Key("DeviceTypeZeroClient")
2924		ok.String(string(v.DeviceTypeZeroClient))
2925	}
2926
2927	return nil
2928}
2929
2930func awsAwsjson11_serializeDocumentWorkspaceCreationProperties(v *types.WorkspaceCreationProperties, value smithyjson.Value) error {
2931	object := value.Object()
2932	defer object.Close()
2933
2934	if v.CustomSecurityGroupId != nil {
2935		ok := object.Key("CustomSecurityGroupId")
2936		ok.String(*v.CustomSecurityGroupId)
2937	}
2938
2939	if v.DefaultOu != nil {
2940		ok := object.Key("DefaultOu")
2941		ok.String(*v.DefaultOu)
2942	}
2943
2944	if v.EnableInternetAccess != nil {
2945		ok := object.Key("EnableInternetAccess")
2946		ok.Boolean(*v.EnableInternetAccess)
2947	}
2948
2949	if v.EnableMaintenanceMode != nil {
2950		ok := object.Key("EnableMaintenanceMode")
2951		ok.Boolean(*v.EnableMaintenanceMode)
2952	}
2953
2954	if v.EnableWorkDocs != nil {
2955		ok := object.Key("EnableWorkDocs")
2956		ok.Boolean(*v.EnableWorkDocs)
2957	}
2958
2959	if v.UserEnabledAsLocalAdministrator != nil {
2960		ok := object.Key("UserEnabledAsLocalAdministrator")
2961		ok.Boolean(*v.UserEnabledAsLocalAdministrator)
2962	}
2963
2964	return nil
2965}
2966
2967func awsAwsjson11_serializeDocumentWorkspaceIdList(v []string, value smithyjson.Value) error {
2968	array := value.Array()
2969	defer array.Close()
2970
2971	for i := range v {
2972		av := array.Value()
2973		av.String(v[i])
2974	}
2975	return nil
2976}
2977
2978func awsAwsjson11_serializeDocumentWorkspaceImageIdList(v []string, value smithyjson.Value) error {
2979	array := value.Array()
2980	defer array.Close()
2981
2982	for i := range v {
2983		av := array.Value()
2984		av.String(v[i])
2985	}
2986	return nil
2987}
2988
2989func awsAwsjson11_serializeDocumentWorkspaceProperties(v *types.WorkspaceProperties, value smithyjson.Value) error {
2990	object := value.Object()
2991	defer object.Close()
2992
2993	if len(v.ComputeTypeName) > 0 {
2994		ok := object.Key("ComputeTypeName")
2995		ok.String(string(v.ComputeTypeName))
2996	}
2997
2998	if v.RootVolumeSizeGib != nil {
2999		ok := object.Key("RootVolumeSizeGib")
3000		ok.Integer(*v.RootVolumeSizeGib)
3001	}
3002
3003	if len(v.RunningMode) > 0 {
3004		ok := object.Key("RunningMode")
3005		ok.String(string(v.RunningMode))
3006	}
3007
3008	if v.RunningModeAutoStopTimeoutInMinutes != nil {
3009		ok := object.Key("RunningModeAutoStopTimeoutInMinutes")
3010		ok.Integer(*v.RunningModeAutoStopTimeoutInMinutes)
3011	}
3012
3013	if v.UserVolumeSizeGib != nil {
3014		ok := object.Key("UserVolumeSizeGib")
3015		ok.Integer(*v.UserVolumeSizeGib)
3016	}
3017
3018	return nil
3019}
3020
3021func awsAwsjson11_serializeDocumentWorkspaceRequest(v *types.WorkspaceRequest, value smithyjson.Value) error {
3022	object := value.Object()
3023	defer object.Close()
3024
3025	if v.BundleId != nil {
3026		ok := object.Key("BundleId")
3027		ok.String(*v.BundleId)
3028	}
3029
3030	if v.DirectoryId != nil {
3031		ok := object.Key("DirectoryId")
3032		ok.String(*v.DirectoryId)
3033	}
3034
3035	if v.RootVolumeEncryptionEnabled != nil {
3036		ok := object.Key("RootVolumeEncryptionEnabled")
3037		ok.Boolean(*v.RootVolumeEncryptionEnabled)
3038	}
3039
3040	if v.Tags != nil {
3041		ok := object.Key("Tags")
3042		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3043			return err
3044		}
3045	}
3046
3047	if v.UserName != nil {
3048		ok := object.Key("UserName")
3049		ok.String(*v.UserName)
3050	}
3051
3052	if v.UserVolumeEncryptionEnabled != nil {
3053		ok := object.Key("UserVolumeEncryptionEnabled")
3054		ok.Boolean(*v.UserVolumeEncryptionEnabled)
3055	}
3056
3057	if v.VolumeEncryptionKey != nil {
3058		ok := object.Key("VolumeEncryptionKey")
3059		ok.String(*v.VolumeEncryptionKey)
3060	}
3061
3062	if v.WorkspaceProperties != nil {
3063		ok := object.Key("WorkspaceProperties")
3064		if err := awsAwsjson11_serializeDocumentWorkspaceProperties(v.WorkspaceProperties, ok); err != nil {
3065			return err
3066		}
3067	}
3068
3069	return nil
3070}
3071
3072func awsAwsjson11_serializeDocumentWorkspaceRequestList(v []types.WorkspaceRequest, value smithyjson.Value) error {
3073	array := value.Array()
3074	defer array.Close()
3075
3076	for i := range v {
3077		av := array.Value()
3078		if err := awsAwsjson11_serializeDocumentWorkspaceRequest(&v[i], av); err != nil {
3079			return err
3080		}
3081	}
3082	return nil
3083}
3084
3085func awsAwsjson11_serializeOpDocumentAssociateConnectionAliasInput(v *AssociateConnectionAliasInput, value smithyjson.Value) error {
3086	object := value.Object()
3087	defer object.Close()
3088
3089	if v.AliasId != nil {
3090		ok := object.Key("AliasId")
3091		ok.String(*v.AliasId)
3092	}
3093
3094	if v.ResourceId != nil {
3095		ok := object.Key("ResourceId")
3096		ok.String(*v.ResourceId)
3097	}
3098
3099	return nil
3100}
3101
3102func awsAwsjson11_serializeOpDocumentAssociateIpGroupsInput(v *AssociateIpGroupsInput, value smithyjson.Value) error {
3103	object := value.Object()
3104	defer object.Close()
3105
3106	if v.DirectoryId != nil {
3107		ok := object.Key("DirectoryId")
3108		ok.String(*v.DirectoryId)
3109	}
3110
3111	if v.GroupIds != nil {
3112		ok := object.Key("GroupIds")
3113		if err := awsAwsjson11_serializeDocumentIpGroupIdList(v.GroupIds, ok); err != nil {
3114			return err
3115		}
3116	}
3117
3118	return nil
3119}
3120
3121func awsAwsjson11_serializeOpDocumentAuthorizeIpRulesInput(v *AuthorizeIpRulesInput, value smithyjson.Value) error {
3122	object := value.Object()
3123	defer object.Close()
3124
3125	if v.GroupId != nil {
3126		ok := object.Key("GroupId")
3127		ok.String(*v.GroupId)
3128	}
3129
3130	if v.UserRules != nil {
3131		ok := object.Key("UserRules")
3132		if err := awsAwsjson11_serializeDocumentIpRuleList(v.UserRules, ok); err != nil {
3133			return err
3134		}
3135	}
3136
3137	return nil
3138}
3139
3140func awsAwsjson11_serializeOpDocumentCopyWorkspaceImageInput(v *CopyWorkspaceImageInput, value smithyjson.Value) error {
3141	object := value.Object()
3142	defer object.Close()
3143
3144	if v.Description != nil {
3145		ok := object.Key("Description")
3146		ok.String(*v.Description)
3147	}
3148
3149	if v.Name != nil {
3150		ok := object.Key("Name")
3151		ok.String(*v.Name)
3152	}
3153
3154	if v.SourceImageId != nil {
3155		ok := object.Key("SourceImageId")
3156		ok.String(*v.SourceImageId)
3157	}
3158
3159	if v.SourceRegion != nil {
3160		ok := object.Key("SourceRegion")
3161		ok.String(*v.SourceRegion)
3162	}
3163
3164	if v.Tags != nil {
3165		ok := object.Key("Tags")
3166		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3167			return err
3168		}
3169	}
3170
3171	return nil
3172}
3173
3174func awsAwsjson11_serializeOpDocumentCreateConnectionAliasInput(v *CreateConnectionAliasInput, value smithyjson.Value) error {
3175	object := value.Object()
3176	defer object.Close()
3177
3178	if v.ConnectionString != nil {
3179		ok := object.Key("ConnectionString")
3180		ok.String(*v.ConnectionString)
3181	}
3182
3183	if v.Tags != nil {
3184		ok := object.Key("Tags")
3185		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3186			return err
3187		}
3188	}
3189
3190	return nil
3191}
3192
3193func awsAwsjson11_serializeOpDocumentCreateIpGroupInput(v *CreateIpGroupInput, value smithyjson.Value) error {
3194	object := value.Object()
3195	defer object.Close()
3196
3197	if v.GroupDesc != nil {
3198		ok := object.Key("GroupDesc")
3199		ok.String(*v.GroupDesc)
3200	}
3201
3202	if v.GroupName != nil {
3203		ok := object.Key("GroupName")
3204		ok.String(*v.GroupName)
3205	}
3206
3207	if v.Tags != nil {
3208		ok := object.Key("Tags")
3209		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3210			return err
3211		}
3212	}
3213
3214	if v.UserRules != nil {
3215		ok := object.Key("UserRules")
3216		if err := awsAwsjson11_serializeDocumentIpRuleList(v.UserRules, ok); err != nil {
3217			return err
3218		}
3219	}
3220
3221	return nil
3222}
3223
3224func awsAwsjson11_serializeOpDocumentCreateTagsInput(v *CreateTagsInput, value smithyjson.Value) error {
3225	object := value.Object()
3226	defer object.Close()
3227
3228	if v.ResourceId != nil {
3229		ok := object.Key("ResourceId")
3230		ok.String(*v.ResourceId)
3231	}
3232
3233	if v.Tags != nil {
3234		ok := object.Key("Tags")
3235		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3236			return err
3237		}
3238	}
3239
3240	return nil
3241}
3242
3243func awsAwsjson11_serializeOpDocumentCreateWorkspaceBundleInput(v *CreateWorkspaceBundleInput, value smithyjson.Value) error {
3244	object := value.Object()
3245	defer object.Close()
3246
3247	if v.BundleDescription != nil {
3248		ok := object.Key("BundleDescription")
3249		ok.String(*v.BundleDescription)
3250	}
3251
3252	if v.BundleName != nil {
3253		ok := object.Key("BundleName")
3254		ok.String(*v.BundleName)
3255	}
3256
3257	if v.ComputeType != nil {
3258		ok := object.Key("ComputeType")
3259		if err := awsAwsjson11_serializeDocumentComputeType(v.ComputeType, ok); err != nil {
3260			return err
3261		}
3262	}
3263
3264	if v.ImageId != nil {
3265		ok := object.Key("ImageId")
3266		ok.String(*v.ImageId)
3267	}
3268
3269	if v.RootStorage != nil {
3270		ok := object.Key("RootStorage")
3271		if err := awsAwsjson11_serializeDocumentRootStorage(v.RootStorage, ok); err != nil {
3272			return err
3273		}
3274	}
3275
3276	if v.Tags != nil {
3277		ok := object.Key("Tags")
3278		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3279			return err
3280		}
3281	}
3282
3283	if v.UserStorage != nil {
3284		ok := object.Key("UserStorage")
3285		if err := awsAwsjson11_serializeDocumentUserStorage(v.UserStorage, ok); err != nil {
3286			return err
3287		}
3288	}
3289
3290	return nil
3291}
3292
3293func awsAwsjson11_serializeOpDocumentCreateWorkspacesInput(v *CreateWorkspacesInput, value smithyjson.Value) error {
3294	object := value.Object()
3295	defer object.Close()
3296
3297	if v.Workspaces != nil {
3298		ok := object.Key("Workspaces")
3299		if err := awsAwsjson11_serializeDocumentWorkspaceRequestList(v.Workspaces, ok); err != nil {
3300			return err
3301		}
3302	}
3303
3304	return nil
3305}
3306
3307func awsAwsjson11_serializeOpDocumentDeleteConnectionAliasInput(v *DeleteConnectionAliasInput, value smithyjson.Value) error {
3308	object := value.Object()
3309	defer object.Close()
3310
3311	if v.AliasId != nil {
3312		ok := object.Key("AliasId")
3313		ok.String(*v.AliasId)
3314	}
3315
3316	return nil
3317}
3318
3319func awsAwsjson11_serializeOpDocumentDeleteIpGroupInput(v *DeleteIpGroupInput, value smithyjson.Value) error {
3320	object := value.Object()
3321	defer object.Close()
3322
3323	if v.GroupId != nil {
3324		ok := object.Key("GroupId")
3325		ok.String(*v.GroupId)
3326	}
3327
3328	return nil
3329}
3330
3331func awsAwsjson11_serializeOpDocumentDeleteTagsInput(v *DeleteTagsInput, value smithyjson.Value) error {
3332	object := value.Object()
3333	defer object.Close()
3334
3335	if v.ResourceId != nil {
3336		ok := object.Key("ResourceId")
3337		ok.String(*v.ResourceId)
3338	}
3339
3340	if v.TagKeys != nil {
3341		ok := object.Key("TagKeys")
3342		if err := awsAwsjson11_serializeDocumentTagKeyList(v.TagKeys, ok); err != nil {
3343			return err
3344		}
3345	}
3346
3347	return nil
3348}
3349
3350func awsAwsjson11_serializeOpDocumentDeleteWorkspaceBundleInput(v *DeleteWorkspaceBundleInput, value smithyjson.Value) error {
3351	object := value.Object()
3352	defer object.Close()
3353
3354	if v.BundleId != nil {
3355		ok := object.Key("BundleId")
3356		ok.String(*v.BundleId)
3357	}
3358
3359	return nil
3360}
3361
3362func awsAwsjson11_serializeOpDocumentDeleteWorkspaceImageInput(v *DeleteWorkspaceImageInput, value smithyjson.Value) error {
3363	object := value.Object()
3364	defer object.Close()
3365
3366	if v.ImageId != nil {
3367		ok := object.Key("ImageId")
3368		ok.String(*v.ImageId)
3369	}
3370
3371	return nil
3372}
3373
3374func awsAwsjson11_serializeOpDocumentDeregisterWorkspaceDirectoryInput(v *DeregisterWorkspaceDirectoryInput, value smithyjson.Value) error {
3375	object := value.Object()
3376	defer object.Close()
3377
3378	if v.DirectoryId != nil {
3379		ok := object.Key("DirectoryId")
3380		ok.String(*v.DirectoryId)
3381	}
3382
3383	return nil
3384}
3385
3386func awsAwsjson11_serializeOpDocumentDescribeAccountInput(v *DescribeAccountInput, value smithyjson.Value) error {
3387	object := value.Object()
3388	defer object.Close()
3389
3390	return nil
3391}
3392
3393func awsAwsjson11_serializeOpDocumentDescribeAccountModificationsInput(v *DescribeAccountModificationsInput, value smithyjson.Value) error {
3394	object := value.Object()
3395	defer object.Close()
3396
3397	if v.NextToken != nil {
3398		ok := object.Key("NextToken")
3399		ok.String(*v.NextToken)
3400	}
3401
3402	return nil
3403}
3404
3405func awsAwsjson11_serializeOpDocumentDescribeClientPropertiesInput(v *DescribeClientPropertiesInput, value smithyjson.Value) error {
3406	object := value.Object()
3407	defer object.Close()
3408
3409	if v.ResourceIds != nil {
3410		ok := object.Key("ResourceIds")
3411		if err := awsAwsjson11_serializeDocumentResourceIdList(v.ResourceIds, ok); err != nil {
3412			return err
3413		}
3414	}
3415
3416	return nil
3417}
3418
3419func awsAwsjson11_serializeOpDocumentDescribeConnectionAliasesInput(v *DescribeConnectionAliasesInput, value smithyjson.Value) error {
3420	object := value.Object()
3421	defer object.Close()
3422
3423	if v.AliasIds != nil {
3424		ok := object.Key("AliasIds")
3425		if err := awsAwsjson11_serializeDocumentConnectionAliasIdList(v.AliasIds, ok); err != nil {
3426			return err
3427		}
3428	}
3429
3430	if v.Limit != nil {
3431		ok := object.Key("Limit")
3432		ok.Integer(*v.Limit)
3433	}
3434
3435	if v.NextToken != nil {
3436		ok := object.Key("NextToken")
3437		ok.String(*v.NextToken)
3438	}
3439
3440	if v.ResourceId != nil {
3441		ok := object.Key("ResourceId")
3442		ok.String(*v.ResourceId)
3443	}
3444
3445	return nil
3446}
3447
3448func awsAwsjson11_serializeOpDocumentDescribeConnectionAliasPermissionsInput(v *DescribeConnectionAliasPermissionsInput, value smithyjson.Value) error {
3449	object := value.Object()
3450	defer object.Close()
3451
3452	if v.AliasId != nil {
3453		ok := object.Key("AliasId")
3454		ok.String(*v.AliasId)
3455	}
3456
3457	if v.MaxResults != nil {
3458		ok := object.Key("MaxResults")
3459		ok.Integer(*v.MaxResults)
3460	}
3461
3462	if v.NextToken != nil {
3463		ok := object.Key("NextToken")
3464		ok.String(*v.NextToken)
3465	}
3466
3467	return nil
3468}
3469
3470func awsAwsjson11_serializeOpDocumentDescribeIpGroupsInput(v *DescribeIpGroupsInput, value smithyjson.Value) error {
3471	object := value.Object()
3472	defer object.Close()
3473
3474	if v.GroupIds != nil {
3475		ok := object.Key("GroupIds")
3476		if err := awsAwsjson11_serializeDocumentIpGroupIdList(v.GroupIds, ok); err != nil {
3477			return err
3478		}
3479	}
3480
3481	if v.MaxResults != nil {
3482		ok := object.Key("MaxResults")
3483		ok.Integer(*v.MaxResults)
3484	}
3485
3486	if v.NextToken != nil {
3487		ok := object.Key("NextToken")
3488		ok.String(*v.NextToken)
3489	}
3490
3491	return nil
3492}
3493
3494func awsAwsjson11_serializeOpDocumentDescribeTagsInput(v *DescribeTagsInput, value smithyjson.Value) error {
3495	object := value.Object()
3496	defer object.Close()
3497
3498	if v.ResourceId != nil {
3499		ok := object.Key("ResourceId")
3500		ok.String(*v.ResourceId)
3501	}
3502
3503	return nil
3504}
3505
3506func awsAwsjson11_serializeOpDocumentDescribeWorkspaceBundlesInput(v *DescribeWorkspaceBundlesInput, value smithyjson.Value) error {
3507	object := value.Object()
3508	defer object.Close()
3509
3510	if v.BundleIds != nil {
3511		ok := object.Key("BundleIds")
3512		if err := awsAwsjson11_serializeDocumentBundleIdList(v.BundleIds, ok); err != nil {
3513			return err
3514		}
3515	}
3516
3517	if v.NextToken != nil {
3518		ok := object.Key("NextToken")
3519		ok.String(*v.NextToken)
3520	}
3521
3522	if v.Owner != nil {
3523		ok := object.Key("Owner")
3524		ok.String(*v.Owner)
3525	}
3526
3527	return nil
3528}
3529
3530func awsAwsjson11_serializeOpDocumentDescribeWorkspaceDirectoriesInput(v *DescribeWorkspaceDirectoriesInput, value smithyjson.Value) error {
3531	object := value.Object()
3532	defer object.Close()
3533
3534	if v.DirectoryIds != nil {
3535		ok := object.Key("DirectoryIds")
3536		if err := awsAwsjson11_serializeDocumentDirectoryIdList(v.DirectoryIds, ok); err != nil {
3537			return err
3538		}
3539	}
3540
3541	if v.Limit != nil {
3542		ok := object.Key("Limit")
3543		ok.Integer(*v.Limit)
3544	}
3545
3546	if v.NextToken != nil {
3547		ok := object.Key("NextToken")
3548		ok.String(*v.NextToken)
3549	}
3550
3551	return nil
3552}
3553
3554func awsAwsjson11_serializeOpDocumentDescribeWorkspaceImagePermissionsInput(v *DescribeWorkspaceImagePermissionsInput, value smithyjson.Value) error {
3555	object := value.Object()
3556	defer object.Close()
3557
3558	if v.ImageId != nil {
3559		ok := object.Key("ImageId")
3560		ok.String(*v.ImageId)
3561	}
3562
3563	if v.MaxResults != nil {
3564		ok := object.Key("MaxResults")
3565		ok.Integer(*v.MaxResults)
3566	}
3567
3568	if v.NextToken != nil {
3569		ok := object.Key("NextToken")
3570		ok.String(*v.NextToken)
3571	}
3572
3573	return nil
3574}
3575
3576func awsAwsjson11_serializeOpDocumentDescribeWorkspaceImagesInput(v *DescribeWorkspaceImagesInput, value smithyjson.Value) error {
3577	object := value.Object()
3578	defer object.Close()
3579
3580	if v.ImageIds != nil {
3581		ok := object.Key("ImageIds")
3582		if err := awsAwsjson11_serializeDocumentWorkspaceImageIdList(v.ImageIds, ok); err != nil {
3583			return err
3584		}
3585	}
3586
3587	if len(v.ImageType) > 0 {
3588		ok := object.Key("ImageType")
3589		ok.String(string(v.ImageType))
3590	}
3591
3592	if v.MaxResults != nil {
3593		ok := object.Key("MaxResults")
3594		ok.Integer(*v.MaxResults)
3595	}
3596
3597	if v.NextToken != nil {
3598		ok := object.Key("NextToken")
3599		ok.String(*v.NextToken)
3600	}
3601
3602	return nil
3603}
3604
3605func awsAwsjson11_serializeOpDocumentDescribeWorkspacesConnectionStatusInput(v *DescribeWorkspacesConnectionStatusInput, value smithyjson.Value) error {
3606	object := value.Object()
3607	defer object.Close()
3608
3609	if v.NextToken != nil {
3610		ok := object.Key("NextToken")
3611		ok.String(*v.NextToken)
3612	}
3613
3614	if v.WorkspaceIds != nil {
3615		ok := object.Key("WorkspaceIds")
3616		if err := awsAwsjson11_serializeDocumentWorkspaceIdList(v.WorkspaceIds, ok); err != nil {
3617			return err
3618		}
3619	}
3620
3621	return nil
3622}
3623
3624func awsAwsjson11_serializeOpDocumentDescribeWorkspacesInput(v *DescribeWorkspacesInput, value smithyjson.Value) error {
3625	object := value.Object()
3626	defer object.Close()
3627
3628	if v.BundleId != nil {
3629		ok := object.Key("BundleId")
3630		ok.String(*v.BundleId)
3631	}
3632
3633	if v.DirectoryId != nil {
3634		ok := object.Key("DirectoryId")
3635		ok.String(*v.DirectoryId)
3636	}
3637
3638	if v.Limit != nil {
3639		ok := object.Key("Limit")
3640		ok.Integer(*v.Limit)
3641	}
3642
3643	if v.NextToken != nil {
3644		ok := object.Key("NextToken")
3645		ok.String(*v.NextToken)
3646	}
3647
3648	if v.UserName != nil {
3649		ok := object.Key("UserName")
3650		ok.String(*v.UserName)
3651	}
3652
3653	if v.WorkspaceIds != nil {
3654		ok := object.Key("WorkspaceIds")
3655		if err := awsAwsjson11_serializeDocumentWorkspaceIdList(v.WorkspaceIds, ok); err != nil {
3656			return err
3657		}
3658	}
3659
3660	return nil
3661}
3662
3663func awsAwsjson11_serializeOpDocumentDescribeWorkspaceSnapshotsInput(v *DescribeWorkspaceSnapshotsInput, value smithyjson.Value) error {
3664	object := value.Object()
3665	defer object.Close()
3666
3667	if v.WorkspaceId != nil {
3668		ok := object.Key("WorkspaceId")
3669		ok.String(*v.WorkspaceId)
3670	}
3671
3672	return nil
3673}
3674
3675func awsAwsjson11_serializeOpDocumentDisassociateConnectionAliasInput(v *DisassociateConnectionAliasInput, value smithyjson.Value) error {
3676	object := value.Object()
3677	defer object.Close()
3678
3679	if v.AliasId != nil {
3680		ok := object.Key("AliasId")
3681		ok.String(*v.AliasId)
3682	}
3683
3684	return nil
3685}
3686
3687func awsAwsjson11_serializeOpDocumentDisassociateIpGroupsInput(v *DisassociateIpGroupsInput, value smithyjson.Value) error {
3688	object := value.Object()
3689	defer object.Close()
3690
3691	if v.DirectoryId != nil {
3692		ok := object.Key("DirectoryId")
3693		ok.String(*v.DirectoryId)
3694	}
3695
3696	if v.GroupIds != nil {
3697		ok := object.Key("GroupIds")
3698		if err := awsAwsjson11_serializeDocumentIpGroupIdList(v.GroupIds, ok); err != nil {
3699			return err
3700		}
3701	}
3702
3703	return nil
3704}
3705
3706func awsAwsjson11_serializeOpDocumentImportWorkspaceImageInput(v *ImportWorkspaceImageInput, value smithyjson.Value) error {
3707	object := value.Object()
3708	defer object.Close()
3709
3710	if v.Applications != nil {
3711		ok := object.Key("Applications")
3712		if err := awsAwsjson11_serializeDocumentApplicationList(v.Applications, ok); err != nil {
3713			return err
3714		}
3715	}
3716
3717	if v.Ec2ImageId != nil {
3718		ok := object.Key("Ec2ImageId")
3719		ok.String(*v.Ec2ImageId)
3720	}
3721
3722	if v.ImageDescription != nil {
3723		ok := object.Key("ImageDescription")
3724		ok.String(*v.ImageDescription)
3725	}
3726
3727	if v.ImageName != nil {
3728		ok := object.Key("ImageName")
3729		ok.String(*v.ImageName)
3730	}
3731
3732	if len(v.IngestionProcess) > 0 {
3733		ok := object.Key("IngestionProcess")
3734		ok.String(string(v.IngestionProcess))
3735	}
3736
3737	if v.Tags != nil {
3738		ok := object.Key("Tags")
3739		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3740			return err
3741		}
3742	}
3743
3744	return nil
3745}
3746
3747func awsAwsjson11_serializeOpDocumentListAvailableManagementCidrRangesInput(v *ListAvailableManagementCidrRangesInput, value smithyjson.Value) error {
3748	object := value.Object()
3749	defer object.Close()
3750
3751	if v.ManagementCidrRangeConstraint != nil {
3752		ok := object.Key("ManagementCidrRangeConstraint")
3753		ok.String(*v.ManagementCidrRangeConstraint)
3754	}
3755
3756	if v.MaxResults != nil {
3757		ok := object.Key("MaxResults")
3758		ok.Integer(*v.MaxResults)
3759	}
3760
3761	if v.NextToken != nil {
3762		ok := object.Key("NextToken")
3763		ok.String(*v.NextToken)
3764	}
3765
3766	return nil
3767}
3768
3769func awsAwsjson11_serializeOpDocumentMigrateWorkspaceInput(v *MigrateWorkspaceInput, value smithyjson.Value) error {
3770	object := value.Object()
3771	defer object.Close()
3772
3773	if v.BundleId != nil {
3774		ok := object.Key("BundleId")
3775		ok.String(*v.BundleId)
3776	}
3777
3778	if v.SourceWorkspaceId != nil {
3779		ok := object.Key("SourceWorkspaceId")
3780		ok.String(*v.SourceWorkspaceId)
3781	}
3782
3783	return nil
3784}
3785
3786func awsAwsjson11_serializeOpDocumentModifyAccountInput(v *ModifyAccountInput, value smithyjson.Value) error {
3787	object := value.Object()
3788	defer object.Close()
3789
3790	if v.DedicatedTenancyManagementCidrRange != nil {
3791		ok := object.Key("DedicatedTenancyManagementCidrRange")
3792		ok.String(*v.DedicatedTenancyManagementCidrRange)
3793	}
3794
3795	if len(v.DedicatedTenancySupport) > 0 {
3796		ok := object.Key("DedicatedTenancySupport")
3797		ok.String(string(v.DedicatedTenancySupport))
3798	}
3799
3800	return nil
3801}
3802
3803func awsAwsjson11_serializeOpDocumentModifyClientPropertiesInput(v *ModifyClientPropertiesInput, value smithyjson.Value) error {
3804	object := value.Object()
3805	defer object.Close()
3806
3807	if v.ClientProperties != nil {
3808		ok := object.Key("ClientProperties")
3809		if err := awsAwsjson11_serializeDocumentClientProperties(v.ClientProperties, ok); err != nil {
3810			return err
3811		}
3812	}
3813
3814	if v.ResourceId != nil {
3815		ok := object.Key("ResourceId")
3816		ok.String(*v.ResourceId)
3817	}
3818
3819	return nil
3820}
3821
3822func awsAwsjson11_serializeOpDocumentModifySelfservicePermissionsInput(v *ModifySelfservicePermissionsInput, value smithyjson.Value) error {
3823	object := value.Object()
3824	defer object.Close()
3825
3826	if v.ResourceId != nil {
3827		ok := object.Key("ResourceId")
3828		ok.String(*v.ResourceId)
3829	}
3830
3831	if v.SelfservicePermissions != nil {
3832		ok := object.Key("SelfservicePermissions")
3833		if err := awsAwsjson11_serializeDocumentSelfservicePermissions(v.SelfservicePermissions, ok); err != nil {
3834			return err
3835		}
3836	}
3837
3838	return nil
3839}
3840
3841func awsAwsjson11_serializeOpDocumentModifyWorkspaceAccessPropertiesInput(v *ModifyWorkspaceAccessPropertiesInput, value smithyjson.Value) error {
3842	object := value.Object()
3843	defer object.Close()
3844
3845	if v.ResourceId != nil {
3846		ok := object.Key("ResourceId")
3847		ok.String(*v.ResourceId)
3848	}
3849
3850	if v.WorkspaceAccessProperties != nil {
3851		ok := object.Key("WorkspaceAccessProperties")
3852		if err := awsAwsjson11_serializeDocumentWorkspaceAccessProperties(v.WorkspaceAccessProperties, ok); err != nil {
3853			return err
3854		}
3855	}
3856
3857	return nil
3858}
3859
3860func awsAwsjson11_serializeOpDocumentModifyWorkspaceCreationPropertiesInput(v *ModifyWorkspaceCreationPropertiesInput, value smithyjson.Value) error {
3861	object := value.Object()
3862	defer object.Close()
3863
3864	if v.ResourceId != nil {
3865		ok := object.Key("ResourceId")
3866		ok.String(*v.ResourceId)
3867	}
3868
3869	if v.WorkspaceCreationProperties != nil {
3870		ok := object.Key("WorkspaceCreationProperties")
3871		if err := awsAwsjson11_serializeDocumentWorkspaceCreationProperties(v.WorkspaceCreationProperties, ok); err != nil {
3872			return err
3873		}
3874	}
3875
3876	return nil
3877}
3878
3879func awsAwsjson11_serializeOpDocumentModifyWorkspacePropertiesInput(v *ModifyWorkspacePropertiesInput, value smithyjson.Value) error {
3880	object := value.Object()
3881	defer object.Close()
3882
3883	if v.WorkspaceId != nil {
3884		ok := object.Key("WorkspaceId")
3885		ok.String(*v.WorkspaceId)
3886	}
3887
3888	if v.WorkspaceProperties != nil {
3889		ok := object.Key("WorkspaceProperties")
3890		if err := awsAwsjson11_serializeDocumentWorkspaceProperties(v.WorkspaceProperties, ok); err != nil {
3891			return err
3892		}
3893	}
3894
3895	return nil
3896}
3897
3898func awsAwsjson11_serializeOpDocumentModifyWorkspaceStateInput(v *ModifyWorkspaceStateInput, value smithyjson.Value) error {
3899	object := value.Object()
3900	defer object.Close()
3901
3902	if v.WorkspaceId != nil {
3903		ok := object.Key("WorkspaceId")
3904		ok.String(*v.WorkspaceId)
3905	}
3906
3907	if len(v.WorkspaceState) > 0 {
3908		ok := object.Key("WorkspaceState")
3909		ok.String(string(v.WorkspaceState))
3910	}
3911
3912	return nil
3913}
3914
3915func awsAwsjson11_serializeOpDocumentRebootWorkspacesInput(v *RebootWorkspacesInput, value smithyjson.Value) error {
3916	object := value.Object()
3917	defer object.Close()
3918
3919	if v.RebootWorkspaceRequests != nil {
3920		ok := object.Key("RebootWorkspaceRequests")
3921		if err := awsAwsjson11_serializeDocumentRebootWorkspaceRequests(v.RebootWorkspaceRequests, ok); err != nil {
3922			return err
3923		}
3924	}
3925
3926	return nil
3927}
3928
3929func awsAwsjson11_serializeOpDocumentRebuildWorkspacesInput(v *RebuildWorkspacesInput, value smithyjson.Value) error {
3930	object := value.Object()
3931	defer object.Close()
3932
3933	if v.RebuildWorkspaceRequests != nil {
3934		ok := object.Key("RebuildWorkspaceRequests")
3935		if err := awsAwsjson11_serializeDocumentRebuildWorkspaceRequests(v.RebuildWorkspaceRequests, ok); err != nil {
3936			return err
3937		}
3938	}
3939
3940	return nil
3941}
3942
3943func awsAwsjson11_serializeOpDocumentRegisterWorkspaceDirectoryInput(v *RegisterWorkspaceDirectoryInput, value smithyjson.Value) error {
3944	object := value.Object()
3945	defer object.Close()
3946
3947	if v.DirectoryId != nil {
3948		ok := object.Key("DirectoryId")
3949		ok.String(*v.DirectoryId)
3950	}
3951
3952	if v.EnableSelfService != nil {
3953		ok := object.Key("EnableSelfService")
3954		ok.Boolean(*v.EnableSelfService)
3955	}
3956
3957	if v.EnableWorkDocs != nil {
3958		ok := object.Key("EnableWorkDocs")
3959		ok.Boolean(*v.EnableWorkDocs)
3960	}
3961
3962	if v.SubnetIds != nil {
3963		ok := object.Key("SubnetIds")
3964		if err := awsAwsjson11_serializeDocumentSubnetIds(v.SubnetIds, ok); err != nil {
3965			return err
3966		}
3967	}
3968
3969	if v.Tags != nil {
3970		ok := object.Key("Tags")
3971		if err := awsAwsjson11_serializeDocumentTagList(v.Tags, ok); err != nil {
3972			return err
3973		}
3974	}
3975
3976	if len(v.Tenancy) > 0 {
3977		ok := object.Key("Tenancy")
3978		ok.String(string(v.Tenancy))
3979	}
3980
3981	return nil
3982}
3983
3984func awsAwsjson11_serializeOpDocumentRestoreWorkspaceInput(v *RestoreWorkspaceInput, value smithyjson.Value) error {
3985	object := value.Object()
3986	defer object.Close()
3987
3988	if v.WorkspaceId != nil {
3989		ok := object.Key("WorkspaceId")
3990		ok.String(*v.WorkspaceId)
3991	}
3992
3993	return nil
3994}
3995
3996func awsAwsjson11_serializeOpDocumentRevokeIpRulesInput(v *RevokeIpRulesInput, value smithyjson.Value) error {
3997	object := value.Object()
3998	defer object.Close()
3999
4000	if v.GroupId != nil {
4001		ok := object.Key("GroupId")
4002		ok.String(*v.GroupId)
4003	}
4004
4005	if v.UserRules != nil {
4006		ok := object.Key("UserRules")
4007		if err := awsAwsjson11_serializeDocumentIpRevokedRuleList(v.UserRules, ok); err != nil {
4008			return err
4009		}
4010	}
4011
4012	return nil
4013}
4014
4015func awsAwsjson11_serializeOpDocumentStartWorkspacesInput(v *StartWorkspacesInput, value smithyjson.Value) error {
4016	object := value.Object()
4017	defer object.Close()
4018
4019	if v.StartWorkspaceRequests != nil {
4020		ok := object.Key("StartWorkspaceRequests")
4021		if err := awsAwsjson11_serializeDocumentStartWorkspaceRequests(v.StartWorkspaceRequests, ok); err != nil {
4022			return err
4023		}
4024	}
4025
4026	return nil
4027}
4028
4029func awsAwsjson11_serializeOpDocumentStopWorkspacesInput(v *StopWorkspacesInput, value smithyjson.Value) error {
4030	object := value.Object()
4031	defer object.Close()
4032
4033	if v.StopWorkspaceRequests != nil {
4034		ok := object.Key("StopWorkspaceRequests")
4035		if err := awsAwsjson11_serializeDocumentStopWorkspaceRequests(v.StopWorkspaceRequests, ok); err != nil {
4036			return err
4037		}
4038	}
4039
4040	return nil
4041}
4042
4043func awsAwsjson11_serializeOpDocumentTerminateWorkspacesInput(v *TerminateWorkspacesInput, value smithyjson.Value) error {
4044	object := value.Object()
4045	defer object.Close()
4046
4047	if v.TerminateWorkspaceRequests != nil {
4048		ok := object.Key("TerminateWorkspaceRequests")
4049		if err := awsAwsjson11_serializeDocumentTerminateWorkspaceRequests(v.TerminateWorkspaceRequests, ok); err != nil {
4050			return err
4051		}
4052	}
4053
4054	return nil
4055}
4056
4057func awsAwsjson11_serializeOpDocumentUpdateConnectionAliasPermissionInput(v *UpdateConnectionAliasPermissionInput, value smithyjson.Value) error {
4058	object := value.Object()
4059	defer object.Close()
4060
4061	if v.AliasId != nil {
4062		ok := object.Key("AliasId")
4063		ok.String(*v.AliasId)
4064	}
4065
4066	if v.ConnectionAliasPermission != nil {
4067		ok := object.Key("ConnectionAliasPermission")
4068		if err := awsAwsjson11_serializeDocumentConnectionAliasPermission(v.ConnectionAliasPermission, ok); err != nil {
4069			return err
4070		}
4071	}
4072
4073	return nil
4074}
4075
4076func awsAwsjson11_serializeOpDocumentUpdateRulesOfIpGroupInput(v *UpdateRulesOfIpGroupInput, value smithyjson.Value) error {
4077	object := value.Object()
4078	defer object.Close()
4079
4080	if v.GroupId != nil {
4081		ok := object.Key("GroupId")
4082		ok.String(*v.GroupId)
4083	}
4084
4085	if v.UserRules != nil {
4086		ok := object.Key("UserRules")
4087		if err := awsAwsjson11_serializeDocumentIpRuleList(v.UserRules, ok); err != nil {
4088			return err
4089		}
4090	}
4091
4092	return nil
4093}
4094
4095func awsAwsjson11_serializeOpDocumentUpdateWorkspaceBundleInput(v *UpdateWorkspaceBundleInput, value smithyjson.Value) error {
4096	object := value.Object()
4097	defer object.Close()
4098
4099	if v.BundleId != nil {
4100		ok := object.Key("BundleId")
4101		ok.String(*v.BundleId)
4102	}
4103
4104	if v.ImageId != nil {
4105		ok := object.Key("ImageId")
4106		ok.String(*v.ImageId)
4107	}
4108
4109	return nil
4110}
4111
4112func awsAwsjson11_serializeOpDocumentUpdateWorkspaceImagePermissionInput(v *UpdateWorkspaceImagePermissionInput, value smithyjson.Value) error {
4113	object := value.Object()
4114	defer object.Close()
4115
4116	if v.AllowCopyImage != nil {
4117		ok := object.Key("AllowCopyImage")
4118		ok.Boolean(*v.AllowCopyImage)
4119	}
4120
4121	if v.ImageId != nil {
4122		ok := object.Key("ImageId")
4123		ok.String(*v.ImageId)
4124	}
4125
4126	if v.SharedAccountId != nil {
4127		ok := object.Key("SharedAccountId")
4128		ok.String(*v.SharedAccountId)
4129	}
4130
4131	return nil
4132}
4133