1// Code generated by smithy-go-codegen DO NOT EDIT.
2
3package quicksight
4
5import (
6	"bytes"
7	"context"
8	"fmt"
9	"github.com/aws/aws-sdk-go-v2/service/quicksight/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	smithytime "github.com/aws/smithy-go/time"
15	smithyhttp "github.com/aws/smithy-go/transport/http"
16	"time"
17)
18
19type awsRestjson1_serializeOpCancelIngestion struct {
20}
21
22func (*awsRestjson1_serializeOpCancelIngestion) ID() string {
23	return "OperationSerializer"
24}
25
26func (m *awsRestjson1_serializeOpCancelIngestion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
27	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
28) {
29	request, ok := in.Request.(*smithyhttp.Request)
30	if !ok {
31		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
32	}
33
34	input, ok := in.Parameters.(*CancelIngestionInput)
35	_ = input
36	if !ok {
37		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
38	}
39
40	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions/{IngestionId}")
41	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
42	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
43	request.Method = "DELETE"
44	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
45	if err != nil {
46		return out, metadata, &smithy.SerializationError{Err: err}
47	}
48
49	if err := awsRestjson1_serializeOpHttpBindingsCancelIngestionInput(input, restEncoder); err != nil {
50		return out, metadata, &smithy.SerializationError{Err: err}
51	}
52
53	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
54		return out, metadata, &smithy.SerializationError{Err: err}
55	}
56	in.Request = request
57
58	return next.HandleSerialize(ctx, in)
59}
60func awsRestjson1_serializeOpHttpBindingsCancelIngestionInput(v *CancelIngestionInput, encoder *httpbinding.Encoder) error {
61	if v == nil {
62		return fmt.Errorf("unsupported serialization of nil %T", v)
63	}
64
65	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
66		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
67	}
68	if v.AwsAccountId != nil {
69		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
70			return err
71		}
72	}
73
74	if v.DataSetId == nil || len(*v.DataSetId) == 0 {
75		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")}
76	}
77	if v.DataSetId != nil {
78		if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil {
79			return err
80		}
81	}
82
83	if v.IngestionId == nil || len(*v.IngestionId) == 0 {
84		return &smithy.SerializationError{Err: fmt.Errorf("input member IngestionId must not be empty")}
85	}
86	if v.IngestionId != nil {
87		if err := encoder.SetURI("IngestionId").String(*v.IngestionId); err != nil {
88			return err
89		}
90	}
91
92	return nil
93}
94
95type awsRestjson1_serializeOpCreateAccountCustomization struct {
96}
97
98func (*awsRestjson1_serializeOpCreateAccountCustomization) ID() string {
99	return "OperationSerializer"
100}
101
102func (m *awsRestjson1_serializeOpCreateAccountCustomization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
103	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
104) {
105	request, ok := in.Request.(*smithyhttp.Request)
106	if !ok {
107		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
108	}
109
110	input, ok := in.Parameters.(*CreateAccountCustomizationInput)
111	_ = input
112	if !ok {
113		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
114	}
115
116	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/customizations")
117	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
118	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
119	request.Method = "POST"
120	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
121	if err != nil {
122		return out, metadata, &smithy.SerializationError{Err: err}
123	}
124
125	if err := awsRestjson1_serializeOpHttpBindingsCreateAccountCustomizationInput(input, restEncoder); err != nil {
126		return out, metadata, &smithy.SerializationError{Err: err}
127	}
128
129	restEncoder.SetHeader("Content-Type").String("application/json")
130
131	jsonEncoder := smithyjson.NewEncoder()
132	if err := awsRestjson1_serializeOpDocumentCreateAccountCustomizationInput(input, jsonEncoder.Value); err != nil {
133		return out, metadata, &smithy.SerializationError{Err: err}
134	}
135
136	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
137		return out, metadata, &smithy.SerializationError{Err: err}
138	}
139
140	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
141		return out, metadata, &smithy.SerializationError{Err: err}
142	}
143	in.Request = request
144
145	return next.HandleSerialize(ctx, in)
146}
147func awsRestjson1_serializeOpHttpBindingsCreateAccountCustomizationInput(v *CreateAccountCustomizationInput, encoder *httpbinding.Encoder) error {
148	if v == nil {
149		return fmt.Errorf("unsupported serialization of nil %T", v)
150	}
151
152	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
153		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
154	}
155	if v.AwsAccountId != nil {
156		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
157			return err
158		}
159	}
160
161	if v.Namespace != nil {
162		encoder.SetQuery("namespace").String(*v.Namespace)
163	}
164
165	return nil
166}
167
168func awsRestjson1_serializeOpDocumentCreateAccountCustomizationInput(v *CreateAccountCustomizationInput, value smithyjson.Value) error {
169	object := value.Object()
170	defer object.Close()
171
172	if v.AccountCustomization != nil {
173		ok := object.Key("AccountCustomization")
174		if err := awsRestjson1_serializeDocumentAccountCustomization(v.AccountCustomization, ok); err != nil {
175			return err
176		}
177	}
178
179	if v.Tags != nil {
180		ok := object.Key("Tags")
181		if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
182			return err
183		}
184	}
185
186	return nil
187}
188
189type awsRestjson1_serializeOpCreateAnalysis struct {
190}
191
192func (*awsRestjson1_serializeOpCreateAnalysis) ID() string {
193	return "OperationSerializer"
194}
195
196func (m *awsRestjson1_serializeOpCreateAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
197	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
198) {
199	request, ok := in.Request.(*smithyhttp.Request)
200	if !ok {
201		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
202	}
203
204	input, ok := in.Parameters.(*CreateAnalysisInput)
205	_ = input
206	if !ok {
207		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
208	}
209
210	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}")
211	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
212	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
213	request.Method = "POST"
214	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
215	if err != nil {
216		return out, metadata, &smithy.SerializationError{Err: err}
217	}
218
219	if err := awsRestjson1_serializeOpHttpBindingsCreateAnalysisInput(input, restEncoder); err != nil {
220		return out, metadata, &smithy.SerializationError{Err: err}
221	}
222
223	restEncoder.SetHeader("Content-Type").String("application/json")
224
225	jsonEncoder := smithyjson.NewEncoder()
226	if err := awsRestjson1_serializeOpDocumentCreateAnalysisInput(input, jsonEncoder.Value); err != nil {
227		return out, metadata, &smithy.SerializationError{Err: err}
228	}
229
230	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
231		return out, metadata, &smithy.SerializationError{Err: err}
232	}
233
234	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
235		return out, metadata, &smithy.SerializationError{Err: err}
236	}
237	in.Request = request
238
239	return next.HandleSerialize(ctx, in)
240}
241func awsRestjson1_serializeOpHttpBindingsCreateAnalysisInput(v *CreateAnalysisInput, encoder *httpbinding.Encoder) error {
242	if v == nil {
243		return fmt.Errorf("unsupported serialization of nil %T", v)
244	}
245
246	if v.AnalysisId == nil || len(*v.AnalysisId) == 0 {
247		return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")}
248	}
249	if v.AnalysisId != nil {
250		if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil {
251			return err
252		}
253	}
254
255	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
256		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
257	}
258	if v.AwsAccountId != nil {
259		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
260			return err
261		}
262	}
263
264	return nil
265}
266
267func awsRestjson1_serializeOpDocumentCreateAnalysisInput(v *CreateAnalysisInput, value smithyjson.Value) error {
268	object := value.Object()
269	defer object.Close()
270
271	if v.Name != nil {
272		ok := object.Key("Name")
273		ok.String(*v.Name)
274	}
275
276	if v.Parameters != nil {
277		ok := object.Key("Parameters")
278		if err := awsRestjson1_serializeDocumentParameters(v.Parameters, ok); err != nil {
279			return err
280		}
281	}
282
283	if v.Permissions != nil {
284		ok := object.Key("Permissions")
285		if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil {
286			return err
287		}
288	}
289
290	if v.SourceEntity != nil {
291		ok := object.Key("SourceEntity")
292		if err := awsRestjson1_serializeDocumentAnalysisSourceEntity(v.SourceEntity, ok); err != nil {
293			return err
294		}
295	}
296
297	if v.Tags != nil {
298		ok := object.Key("Tags")
299		if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
300			return err
301		}
302	}
303
304	if v.ThemeArn != nil {
305		ok := object.Key("ThemeArn")
306		ok.String(*v.ThemeArn)
307	}
308
309	return nil
310}
311
312type awsRestjson1_serializeOpCreateDashboard struct {
313}
314
315func (*awsRestjson1_serializeOpCreateDashboard) ID() string {
316	return "OperationSerializer"
317}
318
319func (m *awsRestjson1_serializeOpCreateDashboard) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
320	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
321) {
322	request, ok := in.Request.(*smithyhttp.Request)
323	if !ok {
324		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
325	}
326
327	input, ok := in.Parameters.(*CreateDashboardInput)
328	_ = input
329	if !ok {
330		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
331	}
332
333	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}")
334	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
335	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
336	request.Method = "POST"
337	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
338	if err != nil {
339		return out, metadata, &smithy.SerializationError{Err: err}
340	}
341
342	if err := awsRestjson1_serializeOpHttpBindingsCreateDashboardInput(input, restEncoder); err != nil {
343		return out, metadata, &smithy.SerializationError{Err: err}
344	}
345
346	restEncoder.SetHeader("Content-Type").String("application/json")
347
348	jsonEncoder := smithyjson.NewEncoder()
349	if err := awsRestjson1_serializeOpDocumentCreateDashboardInput(input, jsonEncoder.Value); err != nil {
350		return out, metadata, &smithy.SerializationError{Err: err}
351	}
352
353	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
354		return out, metadata, &smithy.SerializationError{Err: err}
355	}
356
357	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
358		return out, metadata, &smithy.SerializationError{Err: err}
359	}
360	in.Request = request
361
362	return next.HandleSerialize(ctx, in)
363}
364func awsRestjson1_serializeOpHttpBindingsCreateDashboardInput(v *CreateDashboardInput, encoder *httpbinding.Encoder) error {
365	if v == nil {
366		return fmt.Errorf("unsupported serialization of nil %T", v)
367	}
368
369	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
370		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
371	}
372	if v.AwsAccountId != nil {
373		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
374			return err
375		}
376	}
377
378	if v.DashboardId == nil || len(*v.DashboardId) == 0 {
379		return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")}
380	}
381	if v.DashboardId != nil {
382		if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil {
383			return err
384		}
385	}
386
387	return nil
388}
389
390func awsRestjson1_serializeOpDocumentCreateDashboardInput(v *CreateDashboardInput, value smithyjson.Value) error {
391	object := value.Object()
392	defer object.Close()
393
394	if v.DashboardPublishOptions != nil {
395		ok := object.Key("DashboardPublishOptions")
396		if err := awsRestjson1_serializeDocumentDashboardPublishOptions(v.DashboardPublishOptions, ok); err != nil {
397			return err
398		}
399	}
400
401	if v.Name != nil {
402		ok := object.Key("Name")
403		ok.String(*v.Name)
404	}
405
406	if v.Parameters != nil {
407		ok := object.Key("Parameters")
408		if err := awsRestjson1_serializeDocumentParameters(v.Parameters, ok); err != nil {
409			return err
410		}
411	}
412
413	if v.Permissions != nil {
414		ok := object.Key("Permissions")
415		if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil {
416			return err
417		}
418	}
419
420	if v.SourceEntity != nil {
421		ok := object.Key("SourceEntity")
422		if err := awsRestjson1_serializeDocumentDashboardSourceEntity(v.SourceEntity, ok); err != nil {
423			return err
424		}
425	}
426
427	if v.Tags != nil {
428		ok := object.Key("Tags")
429		if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
430			return err
431		}
432	}
433
434	if v.ThemeArn != nil {
435		ok := object.Key("ThemeArn")
436		ok.String(*v.ThemeArn)
437	}
438
439	if v.VersionDescription != nil {
440		ok := object.Key("VersionDescription")
441		ok.String(*v.VersionDescription)
442	}
443
444	return nil
445}
446
447type awsRestjson1_serializeOpCreateDataSet struct {
448}
449
450func (*awsRestjson1_serializeOpCreateDataSet) ID() string {
451	return "OperationSerializer"
452}
453
454func (m *awsRestjson1_serializeOpCreateDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
455	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
456) {
457	request, ok := in.Request.(*smithyhttp.Request)
458	if !ok {
459		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
460	}
461
462	input, ok := in.Parameters.(*CreateDataSetInput)
463	_ = input
464	if !ok {
465		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
466	}
467
468	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets")
469	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
470	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
471	request.Method = "POST"
472	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
473	if err != nil {
474		return out, metadata, &smithy.SerializationError{Err: err}
475	}
476
477	if err := awsRestjson1_serializeOpHttpBindingsCreateDataSetInput(input, restEncoder); err != nil {
478		return out, metadata, &smithy.SerializationError{Err: err}
479	}
480
481	restEncoder.SetHeader("Content-Type").String("application/json")
482
483	jsonEncoder := smithyjson.NewEncoder()
484	if err := awsRestjson1_serializeOpDocumentCreateDataSetInput(input, jsonEncoder.Value); err != nil {
485		return out, metadata, &smithy.SerializationError{Err: err}
486	}
487
488	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
489		return out, metadata, &smithy.SerializationError{Err: err}
490	}
491
492	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
493		return out, metadata, &smithy.SerializationError{Err: err}
494	}
495	in.Request = request
496
497	return next.HandleSerialize(ctx, in)
498}
499func awsRestjson1_serializeOpHttpBindingsCreateDataSetInput(v *CreateDataSetInput, encoder *httpbinding.Encoder) error {
500	if v == nil {
501		return fmt.Errorf("unsupported serialization of nil %T", v)
502	}
503
504	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
505		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
506	}
507	if v.AwsAccountId != nil {
508		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
509			return err
510		}
511	}
512
513	return nil
514}
515
516func awsRestjson1_serializeOpDocumentCreateDataSetInput(v *CreateDataSetInput, value smithyjson.Value) error {
517	object := value.Object()
518	defer object.Close()
519
520	if v.ColumnGroups != nil {
521		ok := object.Key("ColumnGroups")
522		if err := awsRestjson1_serializeDocumentColumnGroupList(v.ColumnGroups, ok); err != nil {
523			return err
524		}
525	}
526
527	if v.ColumnLevelPermissionRules != nil {
528		ok := object.Key("ColumnLevelPermissionRules")
529		if err := awsRestjson1_serializeDocumentColumnLevelPermissionRuleList(v.ColumnLevelPermissionRules, ok); err != nil {
530			return err
531		}
532	}
533
534	if v.DataSetId != nil {
535		ok := object.Key("DataSetId")
536		ok.String(*v.DataSetId)
537	}
538
539	if v.FieldFolders != nil {
540		ok := object.Key("FieldFolders")
541		if err := awsRestjson1_serializeDocumentFieldFolderMap(v.FieldFolders, ok); err != nil {
542			return err
543		}
544	}
545
546	if len(v.ImportMode) > 0 {
547		ok := object.Key("ImportMode")
548		ok.String(string(v.ImportMode))
549	}
550
551	if v.LogicalTableMap != nil {
552		ok := object.Key("LogicalTableMap")
553		if err := awsRestjson1_serializeDocumentLogicalTableMap(v.LogicalTableMap, ok); err != nil {
554			return err
555		}
556	}
557
558	if v.Name != nil {
559		ok := object.Key("Name")
560		ok.String(*v.Name)
561	}
562
563	if v.Permissions != nil {
564		ok := object.Key("Permissions")
565		if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil {
566			return err
567		}
568	}
569
570	if v.PhysicalTableMap != nil {
571		ok := object.Key("PhysicalTableMap")
572		if err := awsRestjson1_serializeDocumentPhysicalTableMap(v.PhysicalTableMap, ok); err != nil {
573			return err
574		}
575	}
576
577	if v.RowLevelPermissionDataSet != nil {
578		ok := object.Key("RowLevelPermissionDataSet")
579		if err := awsRestjson1_serializeDocumentRowLevelPermissionDataSet(v.RowLevelPermissionDataSet, ok); err != nil {
580			return err
581		}
582	}
583
584	if v.Tags != nil {
585		ok := object.Key("Tags")
586		if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
587			return err
588		}
589	}
590
591	return nil
592}
593
594type awsRestjson1_serializeOpCreateDataSource struct {
595}
596
597func (*awsRestjson1_serializeOpCreateDataSource) ID() string {
598	return "OperationSerializer"
599}
600
601func (m *awsRestjson1_serializeOpCreateDataSource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
602	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
603) {
604	request, ok := in.Request.(*smithyhttp.Request)
605	if !ok {
606		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
607	}
608
609	input, ok := in.Parameters.(*CreateDataSourceInput)
610	_ = input
611	if !ok {
612		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
613	}
614
615	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources")
616	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
617	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
618	request.Method = "POST"
619	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
620	if err != nil {
621		return out, metadata, &smithy.SerializationError{Err: err}
622	}
623
624	if err := awsRestjson1_serializeOpHttpBindingsCreateDataSourceInput(input, restEncoder); err != nil {
625		return out, metadata, &smithy.SerializationError{Err: err}
626	}
627
628	restEncoder.SetHeader("Content-Type").String("application/json")
629
630	jsonEncoder := smithyjson.NewEncoder()
631	if err := awsRestjson1_serializeOpDocumentCreateDataSourceInput(input, jsonEncoder.Value); err != nil {
632		return out, metadata, &smithy.SerializationError{Err: err}
633	}
634
635	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
636		return out, metadata, &smithy.SerializationError{Err: err}
637	}
638
639	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
640		return out, metadata, &smithy.SerializationError{Err: err}
641	}
642	in.Request = request
643
644	return next.HandleSerialize(ctx, in)
645}
646func awsRestjson1_serializeOpHttpBindingsCreateDataSourceInput(v *CreateDataSourceInput, encoder *httpbinding.Encoder) error {
647	if v == nil {
648		return fmt.Errorf("unsupported serialization of nil %T", v)
649	}
650
651	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
652		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
653	}
654	if v.AwsAccountId != nil {
655		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
656			return err
657		}
658	}
659
660	return nil
661}
662
663func awsRestjson1_serializeOpDocumentCreateDataSourceInput(v *CreateDataSourceInput, value smithyjson.Value) error {
664	object := value.Object()
665	defer object.Close()
666
667	if v.Credentials != nil {
668		ok := object.Key("Credentials")
669		if err := awsRestjson1_serializeDocumentDataSourceCredentials(v.Credentials, ok); err != nil {
670			return err
671		}
672	}
673
674	if v.DataSourceId != nil {
675		ok := object.Key("DataSourceId")
676		ok.String(*v.DataSourceId)
677	}
678
679	if v.DataSourceParameters != nil {
680		ok := object.Key("DataSourceParameters")
681		if err := awsRestjson1_serializeDocumentDataSourceParameters(v.DataSourceParameters, ok); err != nil {
682			return err
683		}
684	}
685
686	if v.Name != nil {
687		ok := object.Key("Name")
688		ok.String(*v.Name)
689	}
690
691	if v.Permissions != nil {
692		ok := object.Key("Permissions")
693		if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil {
694			return err
695		}
696	}
697
698	if v.SslProperties != nil {
699		ok := object.Key("SslProperties")
700		if err := awsRestjson1_serializeDocumentSslProperties(v.SslProperties, ok); err != nil {
701			return err
702		}
703	}
704
705	if v.Tags != nil {
706		ok := object.Key("Tags")
707		if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
708			return err
709		}
710	}
711
712	if len(v.Type) > 0 {
713		ok := object.Key("Type")
714		ok.String(string(v.Type))
715	}
716
717	if v.VpcConnectionProperties != nil {
718		ok := object.Key("VpcConnectionProperties")
719		if err := awsRestjson1_serializeDocumentVpcConnectionProperties(v.VpcConnectionProperties, ok); err != nil {
720			return err
721		}
722	}
723
724	return nil
725}
726
727type awsRestjson1_serializeOpCreateGroup struct {
728}
729
730func (*awsRestjson1_serializeOpCreateGroup) ID() string {
731	return "OperationSerializer"
732}
733
734func (m *awsRestjson1_serializeOpCreateGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
735	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
736) {
737	request, ok := in.Request.(*smithyhttp.Request)
738	if !ok {
739		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
740	}
741
742	input, ok := in.Parameters.(*CreateGroupInput)
743	_ = input
744	if !ok {
745		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
746	}
747
748	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups")
749	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
750	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
751	request.Method = "POST"
752	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
753	if err != nil {
754		return out, metadata, &smithy.SerializationError{Err: err}
755	}
756
757	if err := awsRestjson1_serializeOpHttpBindingsCreateGroupInput(input, restEncoder); err != nil {
758		return out, metadata, &smithy.SerializationError{Err: err}
759	}
760
761	restEncoder.SetHeader("Content-Type").String("application/json")
762
763	jsonEncoder := smithyjson.NewEncoder()
764	if err := awsRestjson1_serializeOpDocumentCreateGroupInput(input, jsonEncoder.Value); err != nil {
765		return out, metadata, &smithy.SerializationError{Err: err}
766	}
767
768	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
769		return out, metadata, &smithy.SerializationError{Err: err}
770	}
771
772	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
773		return out, metadata, &smithy.SerializationError{Err: err}
774	}
775	in.Request = request
776
777	return next.HandleSerialize(ctx, in)
778}
779func awsRestjson1_serializeOpHttpBindingsCreateGroupInput(v *CreateGroupInput, encoder *httpbinding.Encoder) error {
780	if v == nil {
781		return fmt.Errorf("unsupported serialization of nil %T", v)
782	}
783
784	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
785		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
786	}
787	if v.AwsAccountId != nil {
788		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
789			return err
790		}
791	}
792
793	if v.Namespace == nil || len(*v.Namespace) == 0 {
794		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
795	}
796	if v.Namespace != nil {
797		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
798			return err
799		}
800	}
801
802	return nil
803}
804
805func awsRestjson1_serializeOpDocumentCreateGroupInput(v *CreateGroupInput, value smithyjson.Value) error {
806	object := value.Object()
807	defer object.Close()
808
809	if v.Description != nil {
810		ok := object.Key("Description")
811		ok.String(*v.Description)
812	}
813
814	if v.GroupName != nil {
815		ok := object.Key("GroupName")
816		ok.String(*v.GroupName)
817	}
818
819	return nil
820}
821
822type awsRestjson1_serializeOpCreateGroupMembership struct {
823}
824
825func (*awsRestjson1_serializeOpCreateGroupMembership) ID() string {
826	return "OperationSerializer"
827}
828
829func (m *awsRestjson1_serializeOpCreateGroupMembership) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
830	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
831) {
832	request, ok := in.Request.(*smithyhttp.Request)
833	if !ok {
834		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
835	}
836
837	input, ok := in.Parameters.(*CreateGroupMembershipInput)
838	_ = input
839	if !ok {
840		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
841	}
842
843	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}/members/{MemberName}")
844	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
845	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
846	request.Method = "PUT"
847	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
848	if err != nil {
849		return out, metadata, &smithy.SerializationError{Err: err}
850	}
851
852	if err := awsRestjson1_serializeOpHttpBindingsCreateGroupMembershipInput(input, restEncoder); err != nil {
853		return out, metadata, &smithy.SerializationError{Err: err}
854	}
855
856	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
857		return out, metadata, &smithy.SerializationError{Err: err}
858	}
859	in.Request = request
860
861	return next.HandleSerialize(ctx, in)
862}
863func awsRestjson1_serializeOpHttpBindingsCreateGroupMembershipInput(v *CreateGroupMembershipInput, encoder *httpbinding.Encoder) error {
864	if v == nil {
865		return fmt.Errorf("unsupported serialization of nil %T", v)
866	}
867
868	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
869		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
870	}
871	if v.AwsAccountId != nil {
872		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
873			return err
874		}
875	}
876
877	if v.GroupName == nil || len(*v.GroupName) == 0 {
878		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")}
879	}
880	if v.GroupName != nil {
881		if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil {
882			return err
883		}
884	}
885
886	if v.MemberName == nil || len(*v.MemberName) == 0 {
887		return &smithy.SerializationError{Err: fmt.Errorf("input member MemberName must not be empty")}
888	}
889	if v.MemberName != nil {
890		if err := encoder.SetURI("MemberName").String(*v.MemberName); err != nil {
891			return err
892		}
893	}
894
895	if v.Namespace == nil || len(*v.Namespace) == 0 {
896		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
897	}
898	if v.Namespace != nil {
899		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
900			return err
901		}
902	}
903
904	return nil
905}
906
907type awsRestjson1_serializeOpCreateIAMPolicyAssignment struct {
908}
909
910func (*awsRestjson1_serializeOpCreateIAMPolicyAssignment) ID() string {
911	return "OperationSerializer"
912}
913
914func (m *awsRestjson1_serializeOpCreateIAMPolicyAssignment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
915	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
916) {
917	request, ok := in.Request.(*smithyhttp.Request)
918	if !ok {
919		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
920	}
921
922	input, ok := in.Parameters.(*CreateIAMPolicyAssignmentInput)
923	_ = input
924	if !ok {
925		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
926	}
927
928	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments")
929	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
930	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
931	request.Method = "POST"
932	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
933	if err != nil {
934		return out, metadata, &smithy.SerializationError{Err: err}
935	}
936
937	if err := awsRestjson1_serializeOpHttpBindingsCreateIAMPolicyAssignmentInput(input, restEncoder); err != nil {
938		return out, metadata, &smithy.SerializationError{Err: err}
939	}
940
941	restEncoder.SetHeader("Content-Type").String("application/json")
942
943	jsonEncoder := smithyjson.NewEncoder()
944	if err := awsRestjson1_serializeOpDocumentCreateIAMPolicyAssignmentInput(input, jsonEncoder.Value); err != nil {
945		return out, metadata, &smithy.SerializationError{Err: err}
946	}
947
948	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
949		return out, metadata, &smithy.SerializationError{Err: err}
950	}
951
952	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
953		return out, metadata, &smithy.SerializationError{Err: err}
954	}
955	in.Request = request
956
957	return next.HandleSerialize(ctx, in)
958}
959func awsRestjson1_serializeOpHttpBindingsCreateIAMPolicyAssignmentInput(v *CreateIAMPolicyAssignmentInput, encoder *httpbinding.Encoder) error {
960	if v == nil {
961		return fmt.Errorf("unsupported serialization of nil %T", v)
962	}
963
964	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
965		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
966	}
967	if v.AwsAccountId != nil {
968		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
969			return err
970		}
971	}
972
973	if v.Namespace == nil || len(*v.Namespace) == 0 {
974		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
975	}
976	if v.Namespace != nil {
977		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
978			return err
979		}
980	}
981
982	return nil
983}
984
985func awsRestjson1_serializeOpDocumentCreateIAMPolicyAssignmentInput(v *CreateIAMPolicyAssignmentInput, value smithyjson.Value) error {
986	object := value.Object()
987	defer object.Close()
988
989	if v.AssignmentName != nil {
990		ok := object.Key("AssignmentName")
991		ok.String(*v.AssignmentName)
992	}
993
994	if len(v.AssignmentStatus) > 0 {
995		ok := object.Key("AssignmentStatus")
996		ok.String(string(v.AssignmentStatus))
997	}
998
999	if v.Identities != nil {
1000		ok := object.Key("Identities")
1001		if err := awsRestjson1_serializeDocumentIdentityMap(v.Identities, ok); err != nil {
1002			return err
1003		}
1004	}
1005
1006	if v.PolicyArn != nil {
1007		ok := object.Key("PolicyArn")
1008		ok.String(*v.PolicyArn)
1009	}
1010
1011	return nil
1012}
1013
1014type awsRestjson1_serializeOpCreateIngestion struct {
1015}
1016
1017func (*awsRestjson1_serializeOpCreateIngestion) ID() string {
1018	return "OperationSerializer"
1019}
1020
1021func (m *awsRestjson1_serializeOpCreateIngestion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1022	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1023) {
1024	request, ok := in.Request.(*smithyhttp.Request)
1025	if !ok {
1026		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1027	}
1028
1029	input, ok := in.Parameters.(*CreateIngestionInput)
1030	_ = input
1031	if !ok {
1032		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1033	}
1034
1035	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions/{IngestionId}")
1036	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1037	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1038	request.Method = "PUT"
1039	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1040	if err != nil {
1041		return out, metadata, &smithy.SerializationError{Err: err}
1042	}
1043
1044	if err := awsRestjson1_serializeOpHttpBindingsCreateIngestionInput(input, restEncoder); err != nil {
1045		return out, metadata, &smithy.SerializationError{Err: err}
1046	}
1047
1048	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1049		return out, metadata, &smithy.SerializationError{Err: err}
1050	}
1051	in.Request = request
1052
1053	return next.HandleSerialize(ctx, in)
1054}
1055func awsRestjson1_serializeOpHttpBindingsCreateIngestionInput(v *CreateIngestionInput, encoder *httpbinding.Encoder) error {
1056	if v == nil {
1057		return fmt.Errorf("unsupported serialization of nil %T", v)
1058	}
1059
1060	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
1061		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
1062	}
1063	if v.AwsAccountId != nil {
1064		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
1065			return err
1066		}
1067	}
1068
1069	if v.DataSetId == nil || len(*v.DataSetId) == 0 {
1070		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")}
1071	}
1072	if v.DataSetId != nil {
1073		if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil {
1074			return err
1075		}
1076	}
1077
1078	if v.IngestionId == nil || len(*v.IngestionId) == 0 {
1079		return &smithy.SerializationError{Err: fmt.Errorf("input member IngestionId must not be empty")}
1080	}
1081	if v.IngestionId != nil {
1082		if err := encoder.SetURI("IngestionId").String(*v.IngestionId); err != nil {
1083			return err
1084		}
1085	}
1086
1087	return nil
1088}
1089
1090type awsRestjson1_serializeOpCreateNamespace struct {
1091}
1092
1093func (*awsRestjson1_serializeOpCreateNamespace) ID() string {
1094	return "OperationSerializer"
1095}
1096
1097func (m *awsRestjson1_serializeOpCreateNamespace) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1098	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1099) {
1100	request, ok := in.Request.(*smithyhttp.Request)
1101	if !ok {
1102		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1103	}
1104
1105	input, ok := in.Parameters.(*CreateNamespaceInput)
1106	_ = input
1107	if !ok {
1108		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1109	}
1110
1111	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}")
1112	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1113	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1114	request.Method = "POST"
1115	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1116	if err != nil {
1117		return out, metadata, &smithy.SerializationError{Err: err}
1118	}
1119
1120	if err := awsRestjson1_serializeOpHttpBindingsCreateNamespaceInput(input, restEncoder); err != nil {
1121		return out, metadata, &smithy.SerializationError{Err: err}
1122	}
1123
1124	restEncoder.SetHeader("Content-Type").String("application/json")
1125
1126	jsonEncoder := smithyjson.NewEncoder()
1127	if err := awsRestjson1_serializeOpDocumentCreateNamespaceInput(input, jsonEncoder.Value); err != nil {
1128		return out, metadata, &smithy.SerializationError{Err: err}
1129	}
1130
1131	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1132		return out, metadata, &smithy.SerializationError{Err: err}
1133	}
1134
1135	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1136		return out, metadata, &smithy.SerializationError{Err: err}
1137	}
1138	in.Request = request
1139
1140	return next.HandleSerialize(ctx, in)
1141}
1142func awsRestjson1_serializeOpHttpBindingsCreateNamespaceInput(v *CreateNamespaceInput, encoder *httpbinding.Encoder) error {
1143	if v == nil {
1144		return fmt.Errorf("unsupported serialization of nil %T", v)
1145	}
1146
1147	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
1148		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
1149	}
1150	if v.AwsAccountId != nil {
1151		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
1152			return err
1153		}
1154	}
1155
1156	return nil
1157}
1158
1159func awsRestjson1_serializeOpDocumentCreateNamespaceInput(v *CreateNamespaceInput, value smithyjson.Value) error {
1160	object := value.Object()
1161	defer object.Close()
1162
1163	if len(v.IdentityStore) > 0 {
1164		ok := object.Key("IdentityStore")
1165		ok.String(string(v.IdentityStore))
1166	}
1167
1168	if v.Namespace != nil {
1169		ok := object.Key("Namespace")
1170		ok.String(*v.Namespace)
1171	}
1172
1173	if v.Tags != nil {
1174		ok := object.Key("Tags")
1175		if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
1176			return err
1177		}
1178	}
1179
1180	return nil
1181}
1182
1183type awsRestjson1_serializeOpCreateTemplate struct {
1184}
1185
1186func (*awsRestjson1_serializeOpCreateTemplate) ID() string {
1187	return "OperationSerializer"
1188}
1189
1190func (m *awsRestjson1_serializeOpCreateTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1191	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1192) {
1193	request, ok := in.Request.(*smithyhttp.Request)
1194	if !ok {
1195		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1196	}
1197
1198	input, ok := in.Parameters.(*CreateTemplateInput)
1199	_ = input
1200	if !ok {
1201		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1202	}
1203
1204	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}")
1205	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1206	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1207	request.Method = "POST"
1208	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1209	if err != nil {
1210		return out, metadata, &smithy.SerializationError{Err: err}
1211	}
1212
1213	if err := awsRestjson1_serializeOpHttpBindingsCreateTemplateInput(input, restEncoder); err != nil {
1214		return out, metadata, &smithy.SerializationError{Err: err}
1215	}
1216
1217	restEncoder.SetHeader("Content-Type").String("application/json")
1218
1219	jsonEncoder := smithyjson.NewEncoder()
1220	if err := awsRestjson1_serializeOpDocumentCreateTemplateInput(input, jsonEncoder.Value); err != nil {
1221		return out, metadata, &smithy.SerializationError{Err: err}
1222	}
1223
1224	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1225		return out, metadata, &smithy.SerializationError{Err: err}
1226	}
1227
1228	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1229		return out, metadata, &smithy.SerializationError{Err: err}
1230	}
1231	in.Request = request
1232
1233	return next.HandleSerialize(ctx, in)
1234}
1235func awsRestjson1_serializeOpHttpBindingsCreateTemplateInput(v *CreateTemplateInput, encoder *httpbinding.Encoder) error {
1236	if v == nil {
1237		return fmt.Errorf("unsupported serialization of nil %T", v)
1238	}
1239
1240	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
1241		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
1242	}
1243	if v.AwsAccountId != nil {
1244		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
1245			return err
1246		}
1247	}
1248
1249	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
1250		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
1251	}
1252	if v.TemplateId != nil {
1253		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
1254			return err
1255		}
1256	}
1257
1258	return nil
1259}
1260
1261func awsRestjson1_serializeOpDocumentCreateTemplateInput(v *CreateTemplateInput, value smithyjson.Value) error {
1262	object := value.Object()
1263	defer object.Close()
1264
1265	if v.Name != nil {
1266		ok := object.Key("Name")
1267		ok.String(*v.Name)
1268	}
1269
1270	if v.Permissions != nil {
1271		ok := object.Key("Permissions")
1272		if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil {
1273			return err
1274		}
1275	}
1276
1277	if v.SourceEntity != nil {
1278		ok := object.Key("SourceEntity")
1279		if err := awsRestjson1_serializeDocumentTemplateSourceEntity(v.SourceEntity, ok); err != nil {
1280			return err
1281		}
1282	}
1283
1284	if v.Tags != nil {
1285		ok := object.Key("Tags")
1286		if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
1287			return err
1288		}
1289	}
1290
1291	if v.VersionDescription != nil {
1292		ok := object.Key("VersionDescription")
1293		ok.String(*v.VersionDescription)
1294	}
1295
1296	return nil
1297}
1298
1299type awsRestjson1_serializeOpCreateTemplateAlias struct {
1300}
1301
1302func (*awsRestjson1_serializeOpCreateTemplateAlias) ID() string {
1303	return "OperationSerializer"
1304}
1305
1306func (m *awsRestjson1_serializeOpCreateTemplateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1307	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1308) {
1309	request, ok := in.Request.(*smithyhttp.Request)
1310	if !ok {
1311		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1312	}
1313
1314	input, ok := in.Parameters.(*CreateTemplateAliasInput)
1315	_ = input
1316	if !ok {
1317		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1318	}
1319
1320	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}")
1321	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1322	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1323	request.Method = "POST"
1324	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1325	if err != nil {
1326		return out, metadata, &smithy.SerializationError{Err: err}
1327	}
1328
1329	if err := awsRestjson1_serializeOpHttpBindingsCreateTemplateAliasInput(input, restEncoder); err != nil {
1330		return out, metadata, &smithy.SerializationError{Err: err}
1331	}
1332
1333	restEncoder.SetHeader("Content-Type").String("application/json")
1334
1335	jsonEncoder := smithyjson.NewEncoder()
1336	if err := awsRestjson1_serializeOpDocumentCreateTemplateAliasInput(input, jsonEncoder.Value); err != nil {
1337		return out, metadata, &smithy.SerializationError{Err: err}
1338	}
1339
1340	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1341		return out, metadata, &smithy.SerializationError{Err: err}
1342	}
1343
1344	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1345		return out, metadata, &smithy.SerializationError{Err: err}
1346	}
1347	in.Request = request
1348
1349	return next.HandleSerialize(ctx, in)
1350}
1351func awsRestjson1_serializeOpHttpBindingsCreateTemplateAliasInput(v *CreateTemplateAliasInput, encoder *httpbinding.Encoder) error {
1352	if v == nil {
1353		return fmt.Errorf("unsupported serialization of nil %T", v)
1354	}
1355
1356	if v.AliasName == nil || len(*v.AliasName) == 0 {
1357		return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")}
1358	}
1359	if v.AliasName != nil {
1360		if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil {
1361			return err
1362		}
1363	}
1364
1365	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
1366		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
1367	}
1368	if v.AwsAccountId != nil {
1369		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
1370			return err
1371		}
1372	}
1373
1374	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
1375		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
1376	}
1377	if v.TemplateId != nil {
1378		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
1379			return err
1380		}
1381	}
1382
1383	return nil
1384}
1385
1386func awsRestjson1_serializeOpDocumentCreateTemplateAliasInput(v *CreateTemplateAliasInput, value smithyjson.Value) error {
1387	object := value.Object()
1388	defer object.Close()
1389
1390	if v.TemplateVersionNumber != nil {
1391		ok := object.Key("TemplateVersionNumber")
1392		ok.Long(*v.TemplateVersionNumber)
1393	}
1394
1395	return nil
1396}
1397
1398type awsRestjson1_serializeOpCreateTheme struct {
1399}
1400
1401func (*awsRestjson1_serializeOpCreateTheme) ID() string {
1402	return "OperationSerializer"
1403}
1404
1405func (m *awsRestjson1_serializeOpCreateTheme) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1406	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1407) {
1408	request, ok := in.Request.(*smithyhttp.Request)
1409	if !ok {
1410		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1411	}
1412
1413	input, ok := in.Parameters.(*CreateThemeInput)
1414	_ = input
1415	if !ok {
1416		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1417	}
1418
1419	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}")
1420	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1421	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1422	request.Method = "POST"
1423	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1424	if err != nil {
1425		return out, metadata, &smithy.SerializationError{Err: err}
1426	}
1427
1428	if err := awsRestjson1_serializeOpHttpBindingsCreateThemeInput(input, restEncoder); err != nil {
1429		return out, metadata, &smithy.SerializationError{Err: err}
1430	}
1431
1432	restEncoder.SetHeader("Content-Type").String("application/json")
1433
1434	jsonEncoder := smithyjson.NewEncoder()
1435	if err := awsRestjson1_serializeOpDocumentCreateThemeInput(input, jsonEncoder.Value); err != nil {
1436		return out, metadata, &smithy.SerializationError{Err: err}
1437	}
1438
1439	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1440		return out, metadata, &smithy.SerializationError{Err: err}
1441	}
1442
1443	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1444		return out, metadata, &smithy.SerializationError{Err: err}
1445	}
1446	in.Request = request
1447
1448	return next.HandleSerialize(ctx, in)
1449}
1450func awsRestjson1_serializeOpHttpBindingsCreateThemeInput(v *CreateThemeInput, encoder *httpbinding.Encoder) error {
1451	if v == nil {
1452		return fmt.Errorf("unsupported serialization of nil %T", v)
1453	}
1454
1455	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
1456		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
1457	}
1458	if v.AwsAccountId != nil {
1459		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
1460			return err
1461		}
1462	}
1463
1464	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
1465		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
1466	}
1467	if v.ThemeId != nil {
1468		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
1469			return err
1470		}
1471	}
1472
1473	return nil
1474}
1475
1476func awsRestjson1_serializeOpDocumentCreateThemeInput(v *CreateThemeInput, value smithyjson.Value) error {
1477	object := value.Object()
1478	defer object.Close()
1479
1480	if v.BaseThemeId != nil {
1481		ok := object.Key("BaseThemeId")
1482		ok.String(*v.BaseThemeId)
1483	}
1484
1485	if v.Configuration != nil {
1486		ok := object.Key("Configuration")
1487		if err := awsRestjson1_serializeDocumentThemeConfiguration(v.Configuration, ok); err != nil {
1488			return err
1489		}
1490	}
1491
1492	if v.Name != nil {
1493		ok := object.Key("Name")
1494		ok.String(*v.Name)
1495	}
1496
1497	if v.Permissions != nil {
1498		ok := object.Key("Permissions")
1499		if err := awsRestjson1_serializeDocumentResourcePermissionList(v.Permissions, ok); err != nil {
1500			return err
1501		}
1502	}
1503
1504	if v.Tags != nil {
1505		ok := object.Key("Tags")
1506		if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
1507			return err
1508		}
1509	}
1510
1511	if v.VersionDescription != nil {
1512		ok := object.Key("VersionDescription")
1513		ok.String(*v.VersionDescription)
1514	}
1515
1516	return nil
1517}
1518
1519type awsRestjson1_serializeOpCreateThemeAlias struct {
1520}
1521
1522func (*awsRestjson1_serializeOpCreateThemeAlias) ID() string {
1523	return "OperationSerializer"
1524}
1525
1526func (m *awsRestjson1_serializeOpCreateThemeAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1527	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1528) {
1529	request, ok := in.Request.(*smithyhttp.Request)
1530	if !ok {
1531		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1532	}
1533
1534	input, ok := in.Parameters.(*CreateThemeAliasInput)
1535	_ = input
1536	if !ok {
1537		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1538	}
1539
1540	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}")
1541	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1542	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1543	request.Method = "POST"
1544	restEncoder, 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
1549	if err := awsRestjson1_serializeOpHttpBindingsCreateThemeAliasInput(input, restEncoder); err != nil {
1550		return out, metadata, &smithy.SerializationError{Err: err}
1551	}
1552
1553	restEncoder.SetHeader("Content-Type").String("application/json")
1554
1555	jsonEncoder := smithyjson.NewEncoder()
1556	if err := awsRestjson1_serializeOpDocumentCreateThemeAliasInput(input, jsonEncoder.Value); err != nil {
1557		return out, metadata, &smithy.SerializationError{Err: err}
1558	}
1559
1560	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
1561		return out, metadata, &smithy.SerializationError{Err: err}
1562	}
1563
1564	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1565		return out, metadata, &smithy.SerializationError{Err: err}
1566	}
1567	in.Request = request
1568
1569	return next.HandleSerialize(ctx, in)
1570}
1571func awsRestjson1_serializeOpHttpBindingsCreateThemeAliasInput(v *CreateThemeAliasInput, encoder *httpbinding.Encoder) error {
1572	if v == nil {
1573		return fmt.Errorf("unsupported serialization of nil %T", v)
1574	}
1575
1576	if v.AliasName == nil || len(*v.AliasName) == 0 {
1577		return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")}
1578	}
1579	if v.AliasName != nil {
1580		if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil {
1581			return err
1582		}
1583	}
1584
1585	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
1586		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
1587	}
1588	if v.AwsAccountId != nil {
1589		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
1590			return err
1591		}
1592	}
1593
1594	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
1595		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
1596	}
1597	if v.ThemeId != nil {
1598		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
1599			return err
1600		}
1601	}
1602
1603	return nil
1604}
1605
1606func awsRestjson1_serializeOpDocumentCreateThemeAliasInput(v *CreateThemeAliasInput, value smithyjson.Value) error {
1607	object := value.Object()
1608	defer object.Close()
1609
1610	if v.ThemeVersionNumber != nil {
1611		ok := object.Key("ThemeVersionNumber")
1612		ok.Long(*v.ThemeVersionNumber)
1613	}
1614
1615	return nil
1616}
1617
1618type awsRestjson1_serializeOpDeleteAccountCustomization struct {
1619}
1620
1621func (*awsRestjson1_serializeOpDeleteAccountCustomization) ID() string {
1622	return "OperationSerializer"
1623}
1624
1625func (m *awsRestjson1_serializeOpDeleteAccountCustomization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1626	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1627) {
1628	request, ok := in.Request.(*smithyhttp.Request)
1629	if !ok {
1630		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1631	}
1632
1633	input, ok := in.Parameters.(*DeleteAccountCustomizationInput)
1634	_ = input
1635	if !ok {
1636		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1637	}
1638
1639	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/customizations")
1640	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1641	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1642	request.Method = "DELETE"
1643	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1644	if err != nil {
1645		return out, metadata, &smithy.SerializationError{Err: err}
1646	}
1647
1648	if err := awsRestjson1_serializeOpHttpBindingsDeleteAccountCustomizationInput(input, restEncoder); err != nil {
1649		return out, metadata, &smithy.SerializationError{Err: err}
1650	}
1651
1652	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1653		return out, metadata, &smithy.SerializationError{Err: err}
1654	}
1655	in.Request = request
1656
1657	return next.HandleSerialize(ctx, in)
1658}
1659func awsRestjson1_serializeOpHttpBindingsDeleteAccountCustomizationInput(v *DeleteAccountCustomizationInput, encoder *httpbinding.Encoder) error {
1660	if v == nil {
1661		return fmt.Errorf("unsupported serialization of nil %T", v)
1662	}
1663
1664	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
1665		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
1666	}
1667	if v.AwsAccountId != nil {
1668		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
1669			return err
1670		}
1671	}
1672
1673	if v.Namespace != nil {
1674		encoder.SetQuery("namespace").String(*v.Namespace)
1675	}
1676
1677	return nil
1678}
1679
1680type awsRestjson1_serializeOpDeleteAnalysis struct {
1681}
1682
1683func (*awsRestjson1_serializeOpDeleteAnalysis) ID() string {
1684	return "OperationSerializer"
1685}
1686
1687func (m *awsRestjson1_serializeOpDeleteAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1688	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1689) {
1690	request, ok := in.Request.(*smithyhttp.Request)
1691	if !ok {
1692		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1693	}
1694
1695	input, ok := in.Parameters.(*DeleteAnalysisInput)
1696	_ = input
1697	if !ok {
1698		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1699	}
1700
1701	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}")
1702	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1703	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1704	request.Method = "DELETE"
1705	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1706	if err != nil {
1707		return out, metadata, &smithy.SerializationError{Err: err}
1708	}
1709
1710	if err := awsRestjson1_serializeOpHttpBindingsDeleteAnalysisInput(input, restEncoder); err != nil {
1711		return out, metadata, &smithy.SerializationError{Err: err}
1712	}
1713
1714	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1715		return out, metadata, &smithy.SerializationError{Err: err}
1716	}
1717	in.Request = request
1718
1719	return next.HandleSerialize(ctx, in)
1720}
1721func awsRestjson1_serializeOpHttpBindingsDeleteAnalysisInput(v *DeleteAnalysisInput, encoder *httpbinding.Encoder) error {
1722	if v == nil {
1723		return fmt.Errorf("unsupported serialization of nil %T", v)
1724	}
1725
1726	if v.AnalysisId == nil || len(*v.AnalysisId) == 0 {
1727		return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")}
1728	}
1729	if v.AnalysisId != nil {
1730		if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil {
1731			return err
1732		}
1733	}
1734
1735	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
1736		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
1737	}
1738	if v.AwsAccountId != nil {
1739		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
1740			return err
1741		}
1742	}
1743
1744	if v.ForceDeleteWithoutRecovery {
1745		encoder.SetQuery("force-delete-without-recovery").Boolean(v.ForceDeleteWithoutRecovery)
1746	}
1747
1748	if v.RecoveryWindowInDays != nil {
1749		encoder.SetQuery("recovery-window-in-days").Long(*v.RecoveryWindowInDays)
1750	}
1751
1752	return nil
1753}
1754
1755type awsRestjson1_serializeOpDeleteDashboard struct {
1756}
1757
1758func (*awsRestjson1_serializeOpDeleteDashboard) ID() string {
1759	return "OperationSerializer"
1760}
1761
1762func (m *awsRestjson1_serializeOpDeleteDashboard) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1763	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1764) {
1765	request, ok := in.Request.(*smithyhttp.Request)
1766	if !ok {
1767		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1768	}
1769
1770	input, ok := in.Parameters.(*DeleteDashboardInput)
1771	_ = input
1772	if !ok {
1773		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1774	}
1775
1776	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}")
1777	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1778	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1779	request.Method = "DELETE"
1780	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1781	if err != nil {
1782		return out, metadata, &smithy.SerializationError{Err: err}
1783	}
1784
1785	if err := awsRestjson1_serializeOpHttpBindingsDeleteDashboardInput(input, restEncoder); err != nil {
1786		return out, metadata, &smithy.SerializationError{Err: err}
1787	}
1788
1789	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1790		return out, metadata, &smithy.SerializationError{Err: err}
1791	}
1792	in.Request = request
1793
1794	return next.HandleSerialize(ctx, in)
1795}
1796func awsRestjson1_serializeOpHttpBindingsDeleteDashboardInput(v *DeleteDashboardInput, encoder *httpbinding.Encoder) error {
1797	if v == nil {
1798		return fmt.Errorf("unsupported serialization of nil %T", v)
1799	}
1800
1801	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
1802		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
1803	}
1804	if v.AwsAccountId != nil {
1805		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
1806			return err
1807		}
1808	}
1809
1810	if v.DashboardId == nil || len(*v.DashboardId) == 0 {
1811		return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")}
1812	}
1813	if v.DashboardId != nil {
1814		if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil {
1815			return err
1816		}
1817	}
1818
1819	if v.VersionNumber != nil {
1820		encoder.SetQuery("version-number").Long(*v.VersionNumber)
1821	}
1822
1823	return nil
1824}
1825
1826type awsRestjson1_serializeOpDeleteDataSet struct {
1827}
1828
1829func (*awsRestjson1_serializeOpDeleteDataSet) ID() string {
1830	return "OperationSerializer"
1831}
1832
1833func (m *awsRestjson1_serializeOpDeleteDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1834	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1835) {
1836	request, ok := in.Request.(*smithyhttp.Request)
1837	if !ok {
1838		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1839	}
1840
1841	input, ok := in.Parameters.(*DeleteDataSetInput)
1842	_ = input
1843	if !ok {
1844		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1845	}
1846
1847	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}")
1848	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1849	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1850	request.Method = "DELETE"
1851	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1852	if err != nil {
1853		return out, metadata, &smithy.SerializationError{Err: err}
1854	}
1855
1856	if err := awsRestjson1_serializeOpHttpBindingsDeleteDataSetInput(input, restEncoder); err != nil {
1857		return out, metadata, &smithy.SerializationError{Err: err}
1858	}
1859
1860	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1861		return out, metadata, &smithy.SerializationError{Err: err}
1862	}
1863	in.Request = request
1864
1865	return next.HandleSerialize(ctx, in)
1866}
1867func awsRestjson1_serializeOpHttpBindingsDeleteDataSetInput(v *DeleteDataSetInput, encoder *httpbinding.Encoder) error {
1868	if v == nil {
1869		return fmt.Errorf("unsupported serialization of nil %T", v)
1870	}
1871
1872	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
1873		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
1874	}
1875	if v.AwsAccountId != nil {
1876		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
1877			return err
1878		}
1879	}
1880
1881	if v.DataSetId == nil || len(*v.DataSetId) == 0 {
1882		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")}
1883	}
1884	if v.DataSetId != nil {
1885		if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil {
1886			return err
1887		}
1888	}
1889
1890	return nil
1891}
1892
1893type awsRestjson1_serializeOpDeleteDataSource struct {
1894}
1895
1896func (*awsRestjson1_serializeOpDeleteDataSource) ID() string {
1897	return "OperationSerializer"
1898}
1899
1900func (m *awsRestjson1_serializeOpDeleteDataSource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1901	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1902) {
1903	request, ok := in.Request.(*smithyhttp.Request)
1904	if !ok {
1905		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1906	}
1907
1908	input, ok := in.Parameters.(*DeleteDataSourceInput)
1909	_ = input
1910	if !ok {
1911		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1912	}
1913
1914	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources/{DataSourceId}")
1915	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1916	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1917	request.Method = "DELETE"
1918	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1919	if err != nil {
1920		return out, metadata, &smithy.SerializationError{Err: err}
1921	}
1922
1923	if err := awsRestjson1_serializeOpHttpBindingsDeleteDataSourceInput(input, restEncoder); err != nil {
1924		return out, metadata, &smithy.SerializationError{Err: err}
1925	}
1926
1927	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1928		return out, metadata, &smithy.SerializationError{Err: err}
1929	}
1930	in.Request = request
1931
1932	return next.HandleSerialize(ctx, in)
1933}
1934func awsRestjson1_serializeOpHttpBindingsDeleteDataSourceInput(v *DeleteDataSourceInput, encoder *httpbinding.Encoder) error {
1935	if v == nil {
1936		return fmt.Errorf("unsupported serialization of nil %T", v)
1937	}
1938
1939	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
1940		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
1941	}
1942	if v.AwsAccountId != nil {
1943		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
1944			return err
1945		}
1946	}
1947
1948	if v.DataSourceId == nil || len(*v.DataSourceId) == 0 {
1949		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSourceId must not be empty")}
1950	}
1951	if v.DataSourceId != nil {
1952		if err := encoder.SetURI("DataSourceId").String(*v.DataSourceId); err != nil {
1953			return err
1954		}
1955	}
1956
1957	return nil
1958}
1959
1960type awsRestjson1_serializeOpDeleteGroup struct {
1961}
1962
1963func (*awsRestjson1_serializeOpDeleteGroup) ID() string {
1964	return "OperationSerializer"
1965}
1966
1967func (m *awsRestjson1_serializeOpDeleteGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
1968	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
1969) {
1970	request, ok := in.Request.(*smithyhttp.Request)
1971	if !ok {
1972		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
1973	}
1974
1975	input, ok := in.Parameters.(*DeleteGroupInput)
1976	_ = input
1977	if !ok {
1978		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
1979	}
1980
1981	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}")
1982	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
1983	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
1984	request.Method = "DELETE"
1985	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
1986	if err != nil {
1987		return out, metadata, &smithy.SerializationError{Err: err}
1988	}
1989
1990	if err := awsRestjson1_serializeOpHttpBindingsDeleteGroupInput(input, restEncoder); err != nil {
1991		return out, metadata, &smithy.SerializationError{Err: err}
1992	}
1993
1994	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
1995		return out, metadata, &smithy.SerializationError{Err: err}
1996	}
1997	in.Request = request
1998
1999	return next.HandleSerialize(ctx, in)
2000}
2001func awsRestjson1_serializeOpHttpBindingsDeleteGroupInput(v *DeleteGroupInput, encoder *httpbinding.Encoder) error {
2002	if v == nil {
2003		return fmt.Errorf("unsupported serialization of nil %T", v)
2004	}
2005
2006	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2007		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2008	}
2009	if v.AwsAccountId != nil {
2010		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2011			return err
2012		}
2013	}
2014
2015	if v.GroupName == nil || len(*v.GroupName) == 0 {
2016		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")}
2017	}
2018	if v.GroupName != nil {
2019		if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil {
2020			return err
2021		}
2022	}
2023
2024	if v.Namespace == nil || len(*v.Namespace) == 0 {
2025		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
2026	}
2027	if v.Namespace != nil {
2028		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
2029			return err
2030		}
2031	}
2032
2033	return nil
2034}
2035
2036type awsRestjson1_serializeOpDeleteGroupMembership struct {
2037}
2038
2039func (*awsRestjson1_serializeOpDeleteGroupMembership) ID() string {
2040	return "OperationSerializer"
2041}
2042
2043func (m *awsRestjson1_serializeOpDeleteGroupMembership) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2044	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2045) {
2046	request, ok := in.Request.(*smithyhttp.Request)
2047	if !ok {
2048		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2049	}
2050
2051	input, ok := in.Parameters.(*DeleteGroupMembershipInput)
2052	_ = input
2053	if !ok {
2054		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2055	}
2056
2057	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}/members/{MemberName}")
2058	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2059	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2060	request.Method = "DELETE"
2061	restEncoder, 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
2066	if err := awsRestjson1_serializeOpHttpBindingsDeleteGroupMembershipInput(input, restEncoder); err != nil {
2067		return out, metadata, &smithy.SerializationError{Err: err}
2068	}
2069
2070	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2071		return out, metadata, &smithy.SerializationError{Err: err}
2072	}
2073	in.Request = request
2074
2075	return next.HandleSerialize(ctx, in)
2076}
2077func awsRestjson1_serializeOpHttpBindingsDeleteGroupMembershipInput(v *DeleteGroupMembershipInput, encoder *httpbinding.Encoder) error {
2078	if v == nil {
2079		return fmt.Errorf("unsupported serialization of nil %T", v)
2080	}
2081
2082	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2083		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2084	}
2085	if v.AwsAccountId != nil {
2086		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2087			return err
2088		}
2089	}
2090
2091	if v.GroupName == nil || len(*v.GroupName) == 0 {
2092		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")}
2093	}
2094	if v.GroupName != nil {
2095		if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil {
2096			return err
2097		}
2098	}
2099
2100	if v.MemberName == nil || len(*v.MemberName) == 0 {
2101		return &smithy.SerializationError{Err: fmt.Errorf("input member MemberName must not be empty")}
2102	}
2103	if v.MemberName != nil {
2104		if err := encoder.SetURI("MemberName").String(*v.MemberName); err != nil {
2105			return err
2106		}
2107	}
2108
2109	if v.Namespace == nil || len(*v.Namespace) == 0 {
2110		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
2111	}
2112	if v.Namespace != nil {
2113		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
2114			return err
2115		}
2116	}
2117
2118	return nil
2119}
2120
2121type awsRestjson1_serializeOpDeleteIAMPolicyAssignment struct {
2122}
2123
2124func (*awsRestjson1_serializeOpDeleteIAMPolicyAssignment) ID() string {
2125	return "OperationSerializer"
2126}
2127
2128func (m *awsRestjson1_serializeOpDeleteIAMPolicyAssignment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2129	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2130) {
2131	request, ok := in.Request.(*smithyhttp.Request)
2132	if !ok {
2133		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2134	}
2135
2136	input, ok := in.Parameters.(*DeleteIAMPolicyAssignmentInput)
2137	_ = input
2138	if !ok {
2139		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2140	}
2141
2142	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespace/{Namespace}/iam-policy-assignments/{AssignmentName}")
2143	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2144	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2145	request.Method = "DELETE"
2146	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2147	if err != nil {
2148		return out, metadata, &smithy.SerializationError{Err: err}
2149	}
2150
2151	if err := awsRestjson1_serializeOpHttpBindingsDeleteIAMPolicyAssignmentInput(input, restEncoder); err != nil {
2152		return out, metadata, &smithy.SerializationError{Err: err}
2153	}
2154
2155	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2156		return out, metadata, &smithy.SerializationError{Err: err}
2157	}
2158	in.Request = request
2159
2160	return next.HandleSerialize(ctx, in)
2161}
2162func awsRestjson1_serializeOpHttpBindingsDeleteIAMPolicyAssignmentInput(v *DeleteIAMPolicyAssignmentInput, encoder *httpbinding.Encoder) error {
2163	if v == nil {
2164		return fmt.Errorf("unsupported serialization of nil %T", v)
2165	}
2166
2167	if v.AssignmentName == nil || len(*v.AssignmentName) == 0 {
2168		return &smithy.SerializationError{Err: fmt.Errorf("input member AssignmentName must not be empty")}
2169	}
2170	if v.AssignmentName != nil {
2171		if err := encoder.SetURI("AssignmentName").String(*v.AssignmentName); err != nil {
2172			return err
2173		}
2174	}
2175
2176	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2177		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2178	}
2179	if v.AwsAccountId != nil {
2180		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2181			return err
2182		}
2183	}
2184
2185	if v.Namespace == nil || len(*v.Namespace) == 0 {
2186		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
2187	}
2188	if v.Namespace != nil {
2189		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
2190			return err
2191		}
2192	}
2193
2194	return nil
2195}
2196
2197type awsRestjson1_serializeOpDeleteNamespace struct {
2198}
2199
2200func (*awsRestjson1_serializeOpDeleteNamespace) ID() string {
2201	return "OperationSerializer"
2202}
2203
2204func (m *awsRestjson1_serializeOpDeleteNamespace) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2205	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2206) {
2207	request, ok := in.Request.(*smithyhttp.Request)
2208	if !ok {
2209		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2210	}
2211
2212	input, ok := in.Parameters.(*DeleteNamespaceInput)
2213	_ = input
2214	if !ok {
2215		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2216	}
2217
2218	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}")
2219	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2220	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2221	request.Method = "DELETE"
2222	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2223	if err != nil {
2224		return out, metadata, &smithy.SerializationError{Err: err}
2225	}
2226
2227	if err := awsRestjson1_serializeOpHttpBindingsDeleteNamespaceInput(input, restEncoder); err != nil {
2228		return out, metadata, &smithy.SerializationError{Err: err}
2229	}
2230
2231	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2232		return out, metadata, &smithy.SerializationError{Err: err}
2233	}
2234	in.Request = request
2235
2236	return next.HandleSerialize(ctx, in)
2237}
2238func awsRestjson1_serializeOpHttpBindingsDeleteNamespaceInput(v *DeleteNamespaceInput, encoder *httpbinding.Encoder) error {
2239	if v == nil {
2240		return fmt.Errorf("unsupported serialization of nil %T", v)
2241	}
2242
2243	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2244		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2245	}
2246	if v.AwsAccountId != nil {
2247		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2248			return err
2249		}
2250	}
2251
2252	if v.Namespace == nil || len(*v.Namespace) == 0 {
2253		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
2254	}
2255	if v.Namespace != nil {
2256		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
2257			return err
2258		}
2259	}
2260
2261	return nil
2262}
2263
2264type awsRestjson1_serializeOpDeleteTemplate struct {
2265}
2266
2267func (*awsRestjson1_serializeOpDeleteTemplate) ID() string {
2268	return "OperationSerializer"
2269}
2270
2271func (m *awsRestjson1_serializeOpDeleteTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2272	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2273) {
2274	request, ok := in.Request.(*smithyhttp.Request)
2275	if !ok {
2276		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2277	}
2278
2279	input, ok := in.Parameters.(*DeleteTemplateInput)
2280	_ = input
2281	if !ok {
2282		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2283	}
2284
2285	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}")
2286	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2287	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2288	request.Method = "DELETE"
2289	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2290	if err != nil {
2291		return out, metadata, &smithy.SerializationError{Err: err}
2292	}
2293
2294	if err := awsRestjson1_serializeOpHttpBindingsDeleteTemplateInput(input, restEncoder); err != nil {
2295		return out, metadata, &smithy.SerializationError{Err: err}
2296	}
2297
2298	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2299		return out, metadata, &smithy.SerializationError{Err: err}
2300	}
2301	in.Request = request
2302
2303	return next.HandleSerialize(ctx, in)
2304}
2305func awsRestjson1_serializeOpHttpBindingsDeleteTemplateInput(v *DeleteTemplateInput, encoder *httpbinding.Encoder) error {
2306	if v == nil {
2307		return fmt.Errorf("unsupported serialization of nil %T", v)
2308	}
2309
2310	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2311		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2312	}
2313	if v.AwsAccountId != nil {
2314		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2315			return err
2316		}
2317	}
2318
2319	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
2320		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
2321	}
2322	if v.TemplateId != nil {
2323		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
2324			return err
2325		}
2326	}
2327
2328	if v.VersionNumber != nil {
2329		encoder.SetQuery("version-number").Long(*v.VersionNumber)
2330	}
2331
2332	return nil
2333}
2334
2335type awsRestjson1_serializeOpDeleteTemplateAlias struct {
2336}
2337
2338func (*awsRestjson1_serializeOpDeleteTemplateAlias) ID() string {
2339	return "OperationSerializer"
2340}
2341
2342func (m *awsRestjson1_serializeOpDeleteTemplateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2343	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2344) {
2345	request, ok := in.Request.(*smithyhttp.Request)
2346	if !ok {
2347		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2348	}
2349
2350	input, ok := in.Parameters.(*DeleteTemplateAliasInput)
2351	_ = input
2352	if !ok {
2353		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2354	}
2355
2356	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}")
2357	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2358	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2359	request.Method = "DELETE"
2360	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2361	if err != nil {
2362		return out, metadata, &smithy.SerializationError{Err: err}
2363	}
2364
2365	if err := awsRestjson1_serializeOpHttpBindingsDeleteTemplateAliasInput(input, restEncoder); err != nil {
2366		return out, metadata, &smithy.SerializationError{Err: err}
2367	}
2368
2369	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2370		return out, metadata, &smithy.SerializationError{Err: err}
2371	}
2372	in.Request = request
2373
2374	return next.HandleSerialize(ctx, in)
2375}
2376func awsRestjson1_serializeOpHttpBindingsDeleteTemplateAliasInput(v *DeleteTemplateAliasInput, encoder *httpbinding.Encoder) error {
2377	if v == nil {
2378		return fmt.Errorf("unsupported serialization of nil %T", v)
2379	}
2380
2381	if v.AliasName == nil || len(*v.AliasName) == 0 {
2382		return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")}
2383	}
2384	if v.AliasName != nil {
2385		if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil {
2386			return err
2387		}
2388	}
2389
2390	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2391		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2392	}
2393	if v.AwsAccountId != nil {
2394		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2395			return err
2396		}
2397	}
2398
2399	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
2400		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
2401	}
2402	if v.TemplateId != nil {
2403		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
2404			return err
2405		}
2406	}
2407
2408	return nil
2409}
2410
2411type awsRestjson1_serializeOpDeleteTheme struct {
2412}
2413
2414func (*awsRestjson1_serializeOpDeleteTheme) ID() string {
2415	return "OperationSerializer"
2416}
2417
2418func (m *awsRestjson1_serializeOpDeleteTheme) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2419	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2420) {
2421	request, ok := in.Request.(*smithyhttp.Request)
2422	if !ok {
2423		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2424	}
2425
2426	input, ok := in.Parameters.(*DeleteThemeInput)
2427	_ = input
2428	if !ok {
2429		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2430	}
2431
2432	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}")
2433	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2434	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2435	request.Method = "DELETE"
2436	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2437	if err != nil {
2438		return out, metadata, &smithy.SerializationError{Err: err}
2439	}
2440
2441	if err := awsRestjson1_serializeOpHttpBindingsDeleteThemeInput(input, restEncoder); err != nil {
2442		return out, metadata, &smithy.SerializationError{Err: err}
2443	}
2444
2445	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2446		return out, metadata, &smithy.SerializationError{Err: err}
2447	}
2448	in.Request = request
2449
2450	return next.HandleSerialize(ctx, in)
2451}
2452func awsRestjson1_serializeOpHttpBindingsDeleteThemeInput(v *DeleteThemeInput, encoder *httpbinding.Encoder) error {
2453	if v == nil {
2454		return fmt.Errorf("unsupported serialization of nil %T", v)
2455	}
2456
2457	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2458		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2459	}
2460	if v.AwsAccountId != nil {
2461		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2462			return err
2463		}
2464	}
2465
2466	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
2467		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
2468	}
2469	if v.ThemeId != nil {
2470		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
2471			return err
2472		}
2473	}
2474
2475	if v.VersionNumber != nil {
2476		encoder.SetQuery("version-number").Long(*v.VersionNumber)
2477	}
2478
2479	return nil
2480}
2481
2482type awsRestjson1_serializeOpDeleteThemeAlias struct {
2483}
2484
2485func (*awsRestjson1_serializeOpDeleteThemeAlias) ID() string {
2486	return "OperationSerializer"
2487}
2488
2489func (m *awsRestjson1_serializeOpDeleteThemeAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2490	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2491) {
2492	request, ok := in.Request.(*smithyhttp.Request)
2493	if !ok {
2494		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2495	}
2496
2497	input, ok := in.Parameters.(*DeleteThemeAliasInput)
2498	_ = input
2499	if !ok {
2500		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2501	}
2502
2503	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}")
2504	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2505	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2506	request.Method = "DELETE"
2507	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2508	if err != nil {
2509		return out, metadata, &smithy.SerializationError{Err: err}
2510	}
2511
2512	if err := awsRestjson1_serializeOpHttpBindingsDeleteThemeAliasInput(input, restEncoder); err != nil {
2513		return out, metadata, &smithy.SerializationError{Err: err}
2514	}
2515
2516	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2517		return out, metadata, &smithy.SerializationError{Err: err}
2518	}
2519	in.Request = request
2520
2521	return next.HandleSerialize(ctx, in)
2522}
2523func awsRestjson1_serializeOpHttpBindingsDeleteThemeAliasInput(v *DeleteThemeAliasInput, encoder *httpbinding.Encoder) error {
2524	if v == nil {
2525		return fmt.Errorf("unsupported serialization of nil %T", v)
2526	}
2527
2528	if v.AliasName == nil || len(*v.AliasName) == 0 {
2529		return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")}
2530	}
2531	if v.AliasName != nil {
2532		if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil {
2533			return err
2534		}
2535	}
2536
2537	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2538		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2539	}
2540	if v.AwsAccountId != nil {
2541		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2542			return err
2543		}
2544	}
2545
2546	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
2547		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
2548	}
2549	if v.ThemeId != nil {
2550		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
2551			return err
2552		}
2553	}
2554
2555	return nil
2556}
2557
2558type awsRestjson1_serializeOpDeleteUser struct {
2559}
2560
2561func (*awsRestjson1_serializeOpDeleteUser) ID() string {
2562	return "OperationSerializer"
2563}
2564
2565func (m *awsRestjson1_serializeOpDeleteUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2566	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2567) {
2568	request, ok := in.Request.(*smithyhttp.Request)
2569	if !ok {
2570		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2571	}
2572
2573	input, ok := in.Parameters.(*DeleteUserInput)
2574	_ = input
2575	if !ok {
2576		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2577	}
2578
2579	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}")
2580	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2581	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2582	request.Method = "DELETE"
2583	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2584	if err != nil {
2585		return out, metadata, &smithy.SerializationError{Err: err}
2586	}
2587
2588	if err := awsRestjson1_serializeOpHttpBindingsDeleteUserInput(input, restEncoder); err != nil {
2589		return out, metadata, &smithy.SerializationError{Err: err}
2590	}
2591
2592	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2593		return out, metadata, &smithy.SerializationError{Err: err}
2594	}
2595	in.Request = request
2596
2597	return next.HandleSerialize(ctx, in)
2598}
2599func awsRestjson1_serializeOpHttpBindingsDeleteUserInput(v *DeleteUserInput, encoder *httpbinding.Encoder) error {
2600	if v == nil {
2601		return fmt.Errorf("unsupported serialization of nil %T", v)
2602	}
2603
2604	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2605		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2606	}
2607	if v.AwsAccountId != nil {
2608		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2609			return err
2610		}
2611	}
2612
2613	if v.Namespace == nil || len(*v.Namespace) == 0 {
2614		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
2615	}
2616	if v.Namespace != nil {
2617		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
2618			return err
2619		}
2620	}
2621
2622	if v.UserName == nil || len(*v.UserName) == 0 {
2623		return &smithy.SerializationError{Err: fmt.Errorf("input member UserName must not be empty")}
2624	}
2625	if v.UserName != nil {
2626		if err := encoder.SetURI("UserName").String(*v.UserName); err != nil {
2627			return err
2628		}
2629	}
2630
2631	return nil
2632}
2633
2634type awsRestjson1_serializeOpDeleteUserByPrincipalId struct {
2635}
2636
2637func (*awsRestjson1_serializeOpDeleteUserByPrincipalId) ID() string {
2638	return "OperationSerializer"
2639}
2640
2641func (m *awsRestjson1_serializeOpDeleteUserByPrincipalId) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2642	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2643) {
2644	request, ok := in.Request.(*smithyhttp.Request)
2645	if !ok {
2646		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2647	}
2648
2649	input, ok := in.Parameters.(*DeleteUserByPrincipalIdInput)
2650	_ = input
2651	if !ok {
2652		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2653	}
2654
2655	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/user-principals/{PrincipalId}")
2656	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2657	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2658	request.Method = "DELETE"
2659	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2660	if err != nil {
2661		return out, metadata, &smithy.SerializationError{Err: err}
2662	}
2663
2664	if err := awsRestjson1_serializeOpHttpBindingsDeleteUserByPrincipalIdInput(input, restEncoder); err != nil {
2665		return out, metadata, &smithy.SerializationError{Err: err}
2666	}
2667
2668	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2669		return out, metadata, &smithy.SerializationError{Err: err}
2670	}
2671	in.Request = request
2672
2673	return next.HandleSerialize(ctx, in)
2674}
2675func awsRestjson1_serializeOpHttpBindingsDeleteUserByPrincipalIdInput(v *DeleteUserByPrincipalIdInput, encoder *httpbinding.Encoder) error {
2676	if v == nil {
2677		return fmt.Errorf("unsupported serialization of nil %T", v)
2678	}
2679
2680	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2681		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2682	}
2683	if v.AwsAccountId != nil {
2684		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2685			return err
2686		}
2687	}
2688
2689	if v.Namespace == nil || len(*v.Namespace) == 0 {
2690		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
2691	}
2692	if v.Namespace != nil {
2693		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
2694			return err
2695		}
2696	}
2697
2698	if v.PrincipalId == nil || len(*v.PrincipalId) == 0 {
2699		return &smithy.SerializationError{Err: fmt.Errorf("input member PrincipalId must not be empty")}
2700	}
2701	if v.PrincipalId != nil {
2702		if err := encoder.SetURI("PrincipalId").String(*v.PrincipalId); err != nil {
2703			return err
2704		}
2705	}
2706
2707	return nil
2708}
2709
2710type awsRestjson1_serializeOpDescribeAccountCustomization struct {
2711}
2712
2713func (*awsRestjson1_serializeOpDescribeAccountCustomization) ID() string {
2714	return "OperationSerializer"
2715}
2716
2717func (m *awsRestjson1_serializeOpDescribeAccountCustomization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2718	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2719) {
2720	request, ok := in.Request.(*smithyhttp.Request)
2721	if !ok {
2722		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2723	}
2724
2725	input, ok := in.Parameters.(*DescribeAccountCustomizationInput)
2726	_ = input
2727	if !ok {
2728		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2729	}
2730
2731	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/customizations")
2732	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2733	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2734	request.Method = "GET"
2735	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2736	if err != nil {
2737		return out, metadata, &smithy.SerializationError{Err: err}
2738	}
2739
2740	if err := awsRestjson1_serializeOpHttpBindingsDescribeAccountCustomizationInput(input, restEncoder); err != nil {
2741		return out, metadata, &smithy.SerializationError{Err: err}
2742	}
2743
2744	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2745		return out, metadata, &smithy.SerializationError{Err: err}
2746	}
2747	in.Request = request
2748
2749	return next.HandleSerialize(ctx, in)
2750}
2751func awsRestjson1_serializeOpHttpBindingsDescribeAccountCustomizationInput(v *DescribeAccountCustomizationInput, encoder *httpbinding.Encoder) error {
2752	if v == nil {
2753		return fmt.Errorf("unsupported serialization of nil %T", v)
2754	}
2755
2756	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2757		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2758	}
2759	if v.AwsAccountId != nil {
2760		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2761			return err
2762		}
2763	}
2764
2765	if v.Namespace != nil {
2766		encoder.SetQuery("namespace").String(*v.Namespace)
2767	}
2768
2769	if v.Resolved {
2770		encoder.SetQuery("resolved").Boolean(v.Resolved)
2771	}
2772
2773	return nil
2774}
2775
2776type awsRestjson1_serializeOpDescribeAccountSettings struct {
2777}
2778
2779func (*awsRestjson1_serializeOpDescribeAccountSettings) ID() string {
2780	return "OperationSerializer"
2781}
2782
2783func (m *awsRestjson1_serializeOpDescribeAccountSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2784	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2785) {
2786	request, ok := in.Request.(*smithyhttp.Request)
2787	if !ok {
2788		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2789	}
2790
2791	input, ok := in.Parameters.(*DescribeAccountSettingsInput)
2792	_ = input
2793	if !ok {
2794		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2795	}
2796
2797	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/settings")
2798	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2799	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2800	request.Method = "GET"
2801	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2802	if err != nil {
2803		return out, metadata, &smithy.SerializationError{Err: err}
2804	}
2805
2806	if err := awsRestjson1_serializeOpHttpBindingsDescribeAccountSettingsInput(input, restEncoder); err != nil {
2807		return out, metadata, &smithy.SerializationError{Err: err}
2808	}
2809
2810	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2811		return out, metadata, &smithy.SerializationError{Err: err}
2812	}
2813	in.Request = request
2814
2815	return next.HandleSerialize(ctx, in)
2816}
2817func awsRestjson1_serializeOpHttpBindingsDescribeAccountSettingsInput(v *DescribeAccountSettingsInput, encoder *httpbinding.Encoder) error {
2818	if v == nil {
2819		return fmt.Errorf("unsupported serialization of nil %T", v)
2820	}
2821
2822	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2823		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2824	}
2825	if v.AwsAccountId != nil {
2826		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2827			return err
2828		}
2829	}
2830
2831	return nil
2832}
2833
2834type awsRestjson1_serializeOpDescribeAnalysis struct {
2835}
2836
2837func (*awsRestjson1_serializeOpDescribeAnalysis) ID() string {
2838	return "OperationSerializer"
2839}
2840
2841func (m *awsRestjson1_serializeOpDescribeAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2842	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2843) {
2844	request, ok := in.Request.(*smithyhttp.Request)
2845	if !ok {
2846		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2847	}
2848
2849	input, ok := in.Parameters.(*DescribeAnalysisInput)
2850	_ = input
2851	if !ok {
2852		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2853	}
2854
2855	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}")
2856	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2857	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2858	request.Method = "GET"
2859	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2860	if err != nil {
2861		return out, metadata, &smithy.SerializationError{Err: err}
2862	}
2863
2864	if err := awsRestjson1_serializeOpHttpBindingsDescribeAnalysisInput(input, restEncoder); err != nil {
2865		return out, metadata, &smithy.SerializationError{Err: err}
2866	}
2867
2868	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2869		return out, metadata, &smithy.SerializationError{Err: err}
2870	}
2871	in.Request = request
2872
2873	return next.HandleSerialize(ctx, in)
2874}
2875func awsRestjson1_serializeOpHttpBindingsDescribeAnalysisInput(v *DescribeAnalysisInput, encoder *httpbinding.Encoder) error {
2876	if v == nil {
2877		return fmt.Errorf("unsupported serialization of nil %T", v)
2878	}
2879
2880	if v.AnalysisId == nil || len(*v.AnalysisId) == 0 {
2881		return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")}
2882	}
2883	if v.AnalysisId != nil {
2884		if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil {
2885			return err
2886		}
2887	}
2888
2889	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2890		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2891	}
2892	if v.AwsAccountId != nil {
2893		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2894			return err
2895		}
2896	}
2897
2898	return nil
2899}
2900
2901type awsRestjson1_serializeOpDescribeAnalysisPermissions struct {
2902}
2903
2904func (*awsRestjson1_serializeOpDescribeAnalysisPermissions) ID() string {
2905	return "OperationSerializer"
2906}
2907
2908func (m *awsRestjson1_serializeOpDescribeAnalysisPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2909	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2910) {
2911	request, ok := in.Request.(*smithyhttp.Request)
2912	if !ok {
2913		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2914	}
2915
2916	input, ok := in.Parameters.(*DescribeAnalysisPermissionsInput)
2917	_ = input
2918	if !ok {
2919		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2920	}
2921
2922	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}/permissions")
2923	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2924	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2925	request.Method = "GET"
2926	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2927	if err != nil {
2928		return out, metadata, &smithy.SerializationError{Err: err}
2929	}
2930
2931	if err := awsRestjson1_serializeOpHttpBindingsDescribeAnalysisPermissionsInput(input, restEncoder); err != nil {
2932		return out, metadata, &smithy.SerializationError{Err: err}
2933	}
2934
2935	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
2936		return out, metadata, &smithy.SerializationError{Err: err}
2937	}
2938	in.Request = request
2939
2940	return next.HandleSerialize(ctx, in)
2941}
2942func awsRestjson1_serializeOpHttpBindingsDescribeAnalysisPermissionsInput(v *DescribeAnalysisPermissionsInput, encoder *httpbinding.Encoder) error {
2943	if v == nil {
2944		return fmt.Errorf("unsupported serialization of nil %T", v)
2945	}
2946
2947	if v.AnalysisId == nil || len(*v.AnalysisId) == 0 {
2948		return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")}
2949	}
2950	if v.AnalysisId != nil {
2951		if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil {
2952			return err
2953		}
2954	}
2955
2956	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
2957		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
2958	}
2959	if v.AwsAccountId != nil {
2960		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
2961			return err
2962		}
2963	}
2964
2965	return nil
2966}
2967
2968type awsRestjson1_serializeOpDescribeDashboard struct {
2969}
2970
2971func (*awsRestjson1_serializeOpDescribeDashboard) ID() string {
2972	return "OperationSerializer"
2973}
2974
2975func (m *awsRestjson1_serializeOpDescribeDashboard) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
2976	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
2977) {
2978	request, ok := in.Request.(*smithyhttp.Request)
2979	if !ok {
2980		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
2981	}
2982
2983	input, ok := in.Parameters.(*DescribeDashboardInput)
2984	_ = input
2985	if !ok {
2986		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
2987	}
2988
2989	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}")
2990	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
2991	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
2992	request.Method = "GET"
2993	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
2994	if err != nil {
2995		return out, metadata, &smithy.SerializationError{Err: err}
2996	}
2997
2998	if err := awsRestjson1_serializeOpHttpBindingsDescribeDashboardInput(input, restEncoder); err != nil {
2999		return out, metadata, &smithy.SerializationError{Err: err}
3000	}
3001
3002	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3003		return out, metadata, &smithy.SerializationError{Err: err}
3004	}
3005	in.Request = request
3006
3007	return next.HandleSerialize(ctx, in)
3008}
3009func awsRestjson1_serializeOpHttpBindingsDescribeDashboardInput(v *DescribeDashboardInput, encoder *httpbinding.Encoder) error {
3010	if v == nil {
3011		return fmt.Errorf("unsupported serialization of nil %T", v)
3012	}
3013
3014	if v.AliasName != nil {
3015		encoder.SetQuery("alias-name").String(*v.AliasName)
3016	}
3017
3018	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3019		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3020	}
3021	if v.AwsAccountId != nil {
3022		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3023			return err
3024		}
3025	}
3026
3027	if v.DashboardId == nil || len(*v.DashboardId) == 0 {
3028		return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")}
3029	}
3030	if v.DashboardId != nil {
3031		if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil {
3032			return err
3033		}
3034	}
3035
3036	if v.VersionNumber != nil {
3037		encoder.SetQuery("version-number").Long(*v.VersionNumber)
3038	}
3039
3040	return nil
3041}
3042
3043type awsRestjson1_serializeOpDescribeDashboardPermissions struct {
3044}
3045
3046func (*awsRestjson1_serializeOpDescribeDashboardPermissions) ID() string {
3047	return "OperationSerializer"
3048}
3049
3050func (m *awsRestjson1_serializeOpDescribeDashboardPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3051	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3052) {
3053	request, ok := in.Request.(*smithyhttp.Request)
3054	if !ok {
3055		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3056	}
3057
3058	input, ok := in.Parameters.(*DescribeDashboardPermissionsInput)
3059	_ = input
3060	if !ok {
3061		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3062	}
3063
3064	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}/permissions")
3065	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3066	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3067	request.Method = "GET"
3068	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3069	if err != nil {
3070		return out, metadata, &smithy.SerializationError{Err: err}
3071	}
3072
3073	if err := awsRestjson1_serializeOpHttpBindingsDescribeDashboardPermissionsInput(input, restEncoder); err != nil {
3074		return out, metadata, &smithy.SerializationError{Err: err}
3075	}
3076
3077	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3078		return out, metadata, &smithy.SerializationError{Err: err}
3079	}
3080	in.Request = request
3081
3082	return next.HandleSerialize(ctx, in)
3083}
3084func awsRestjson1_serializeOpHttpBindingsDescribeDashboardPermissionsInput(v *DescribeDashboardPermissionsInput, encoder *httpbinding.Encoder) error {
3085	if v == nil {
3086		return fmt.Errorf("unsupported serialization of nil %T", v)
3087	}
3088
3089	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3090		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3091	}
3092	if v.AwsAccountId != nil {
3093		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3094			return err
3095		}
3096	}
3097
3098	if v.DashboardId == nil || len(*v.DashboardId) == 0 {
3099		return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")}
3100	}
3101	if v.DashboardId != nil {
3102		if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil {
3103			return err
3104		}
3105	}
3106
3107	return nil
3108}
3109
3110type awsRestjson1_serializeOpDescribeDataSet struct {
3111}
3112
3113func (*awsRestjson1_serializeOpDescribeDataSet) ID() string {
3114	return "OperationSerializer"
3115}
3116
3117func (m *awsRestjson1_serializeOpDescribeDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3118	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3119) {
3120	request, ok := in.Request.(*smithyhttp.Request)
3121	if !ok {
3122		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3123	}
3124
3125	input, ok := in.Parameters.(*DescribeDataSetInput)
3126	_ = input
3127	if !ok {
3128		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3129	}
3130
3131	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}")
3132	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3133	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3134	request.Method = "GET"
3135	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3136	if err != nil {
3137		return out, metadata, &smithy.SerializationError{Err: err}
3138	}
3139
3140	if err := awsRestjson1_serializeOpHttpBindingsDescribeDataSetInput(input, restEncoder); err != nil {
3141		return out, metadata, &smithy.SerializationError{Err: err}
3142	}
3143
3144	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3145		return out, metadata, &smithy.SerializationError{Err: err}
3146	}
3147	in.Request = request
3148
3149	return next.HandleSerialize(ctx, in)
3150}
3151func awsRestjson1_serializeOpHttpBindingsDescribeDataSetInput(v *DescribeDataSetInput, encoder *httpbinding.Encoder) error {
3152	if v == nil {
3153		return fmt.Errorf("unsupported serialization of nil %T", v)
3154	}
3155
3156	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3157		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3158	}
3159	if v.AwsAccountId != nil {
3160		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3161			return err
3162		}
3163	}
3164
3165	if v.DataSetId == nil || len(*v.DataSetId) == 0 {
3166		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")}
3167	}
3168	if v.DataSetId != nil {
3169		if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil {
3170			return err
3171		}
3172	}
3173
3174	return nil
3175}
3176
3177type awsRestjson1_serializeOpDescribeDataSetPermissions struct {
3178}
3179
3180func (*awsRestjson1_serializeOpDescribeDataSetPermissions) ID() string {
3181	return "OperationSerializer"
3182}
3183
3184func (m *awsRestjson1_serializeOpDescribeDataSetPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3185	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3186) {
3187	request, ok := in.Request.(*smithyhttp.Request)
3188	if !ok {
3189		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3190	}
3191
3192	input, ok := in.Parameters.(*DescribeDataSetPermissionsInput)
3193	_ = input
3194	if !ok {
3195		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3196	}
3197
3198	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/permissions")
3199	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3200	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3201	request.Method = "GET"
3202	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3203	if err != nil {
3204		return out, metadata, &smithy.SerializationError{Err: err}
3205	}
3206
3207	if err := awsRestjson1_serializeOpHttpBindingsDescribeDataSetPermissionsInput(input, restEncoder); err != nil {
3208		return out, metadata, &smithy.SerializationError{Err: err}
3209	}
3210
3211	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3212		return out, metadata, &smithy.SerializationError{Err: err}
3213	}
3214	in.Request = request
3215
3216	return next.HandleSerialize(ctx, in)
3217}
3218func awsRestjson1_serializeOpHttpBindingsDescribeDataSetPermissionsInput(v *DescribeDataSetPermissionsInput, encoder *httpbinding.Encoder) error {
3219	if v == nil {
3220		return fmt.Errorf("unsupported serialization of nil %T", v)
3221	}
3222
3223	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3224		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3225	}
3226	if v.AwsAccountId != nil {
3227		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3228			return err
3229		}
3230	}
3231
3232	if v.DataSetId == nil || len(*v.DataSetId) == 0 {
3233		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")}
3234	}
3235	if v.DataSetId != nil {
3236		if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil {
3237			return err
3238		}
3239	}
3240
3241	return nil
3242}
3243
3244type awsRestjson1_serializeOpDescribeDataSource struct {
3245}
3246
3247func (*awsRestjson1_serializeOpDescribeDataSource) ID() string {
3248	return "OperationSerializer"
3249}
3250
3251func (m *awsRestjson1_serializeOpDescribeDataSource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3252	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3253) {
3254	request, ok := in.Request.(*smithyhttp.Request)
3255	if !ok {
3256		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3257	}
3258
3259	input, ok := in.Parameters.(*DescribeDataSourceInput)
3260	_ = input
3261	if !ok {
3262		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3263	}
3264
3265	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources/{DataSourceId}")
3266	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3267	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3268	request.Method = "GET"
3269	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3270	if err != nil {
3271		return out, metadata, &smithy.SerializationError{Err: err}
3272	}
3273
3274	if err := awsRestjson1_serializeOpHttpBindingsDescribeDataSourceInput(input, restEncoder); err != nil {
3275		return out, metadata, &smithy.SerializationError{Err: err}
3276	}
3277
3278	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3279		return out, metadata, &smithy.SerializationError{Err: err}
3280	}
3281	in.Request = request
3282
3283	return next.HandleSerialize(ctx, in)
3284}
3285func awsRestjson1_serializeOpHttpBindingsDescribeDataSourceInput(v *DescribeDataSourceInput, encoder *httpbinding.Encoder) error {
3286	if v == nil {
3287		return fmt.Errorf("unsupported serialization of nil %T", v)
3288	}
3289
3290	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3291		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3292	}
3293	if v.AwsAccountId != nil {
3294		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3295			return err
3296		}
3297	}
3298
3299	if v.DataSourceId == nil || len(*v.DataSourceId) == 0 {
3300		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSourceId must not be empty")}
3301	}
3302	if v.DataSourceId != nil {
3303		if err := encoder.SetURI("DataSourceId").String(*v.DataSourceId); err != nil {
3304			return err
3305		}
3306	}
3307
3308	return nil
3309}
3310
3311type awsRestjson1_serializeOpDescribeDataSourcePermissions struct {
3312}
3313
3314func (*awsRestjson1_serializeOpDescribeDataSourcePermissions) ID() string {
3315	return "OperationSerializer"
3316}
3317
3318func (m *awsRestjson1_serializeOpDescribeDataSourcePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3319	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3320) {
3321	request, ok := in.Request.(*smithyhttp.Request)
3322	if !ok {
3323		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3324	}
3325
3326	input, ok := in.Parameters.(*DescribeDataSourcePermissionsInput)
3327	_ = input
3328	if !ok {
3329		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3330	}
3331
3332	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources/{DataSourceId}/permissions")
3333	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3334	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3335	request.Method = "GET"
3336	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3337	if err != nil {
3338		return out, metadata, &smithy.SerializationError{Err: err}
3339	}
3340
3341	if err := awsRestjson1_serializeOpHttpBindingsDescribeDataSourcePermissionsInput(input, restEncoder); err != nil {
3342		return out, metadata, &smithy.SerializationError{Err: err}
3343	}
3344
3345	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3346		return out, metadata, &smithy.SerializationError{Err: err}
3347	}
3348	in.Request = request
3349
3350	return next.HandleSerialize(ctx, in)
3351}
3352func awsRestjson1_serializeOpHttpBindingsDescribeDataSourcePermissionsInput(v *DescribeDataSourcePermissionsInput, encoder *httpbinding.Encoder) error {
3353	if v == nil {
3354		return fmt.Errorf("unsupported serialization of nil %T", v)
3355	}
3356
3357	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3358		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3359	}
3360	if v.AwsAccountId != nil {
3361		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3362			return err
3363		}
3364	}
3365
3366	if v.DataSourceId == nil || len(*v.DataSourceId) == 0 {
3367		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSourceId must not be empty")}
3368	}
3369	if v.DataSourceId != nil {
3370		if err := encoder.SetURI("DataSourceId").String(*v.DataSourceId); err != nil {
3371			return err
3372		}
3373	}
3374
3375	return nil
3376}
3377
3378type awsRestjson1_serializeOpDescribeGroup struct {
3379}
3380
3381func (*awsRestjson1_serializeOpDescribeGroup) ID() string {
3382	return "OperationSerializer"
3383}
3384
3385func (m *awsRestjson1_serializeOpDescribeGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3386	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3387) {
3388	request, ok := in.Request.(*smithyhttp.Request)
3389	if !ok {
3390		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3391	}
3392
3393	input, ok := in.Parameters.(*DescribeGroupInput)
3394	_ = input
3395	if !ok {
3396		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3397	}
3398
3399	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}")
3400	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3401	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3402	request.Method = "GET"
3403	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3404	if err != nil {
3405		return out, metadata, &smithy.SerializationError{Err: err}
3406	}
3407
3408	if err := awsRestjson1_serializeOpHttpBindingsDescribeGroupInput(input, restEncoder); err != nil {
3409		return out, metadata, &smithy.SerializationError{Err: err}
3410	}
3411
3412	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3413		return out, metadata, &smithy.SerializationError{Err: err}
3414	}
3415	in.Request = request
3416
3417	return next.HandleSerialize(ctx, in)
3418}
3419func awsRestjson1_serializeOpHttpBindingsDescribeGroupInput(v *DescribeGroupInput, encoder *httpbinding.Encoder) error {
3420	if v == nil {
3421		return fmt.Errorf("unsupported serialization of nil %T", v)
3422	}
3423
3424	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3425		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3426	}
3427	if v.AwsAccountId != nil {
3428		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3429			return err
3430		}
3431	}
3432
3433	if v.GroupName == nil || len(*v.GroupName) == 0 {
3434		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")}
3435	}
3436	if v.GroupName != nil {
3437		if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil {
3438			return err
3439		}
3440	}
3441
3442	if v.Namespace == nil || len(*v.Namespace) == 0 {
3443		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
3444	}
3445	if v.Namespace != nil {
3446		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
3447			return err
3448		}
3449	}
3450
3451	return nil
3452}
3453
3454type awsRestjson1_serializeOpDescribeIAMPolicyAssignment struct {
3455}
3456
3457func (*awsRestjson1_serializeOpDescribeIAMPolicyAssignment) ID() string {
3458	return "OperationSerializer"
3459}
3460
3461func (m *awsRestjson1_serializeOpDescribeIAMPolicyAssignment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3462	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3463) {
3464	request, ok := in.Request.(*smithyhttp.Request)
3465	if !ok {
3466		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3467	}
3468
3469	input, ok := in.Parameters.(*DescribeIAMPolicyAssignmentInput)
3470	_ = input
3471	if !ok {
3472		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3473	}
3474
3475	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments/{AssignmentName}")
3476	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3477	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3478	request.Method = "GET"
3479	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3480	if err != nil {
3481		return out, metadata, &smithy.SerializationError{Err: err}
3482	}
3483
3484	if err := awsRestjson1_serializeOpHttpBindingsDescribeIAMPolicyAssignmentInput(input, restEncoder); err != nil {
3485		return out, metadata, &smithy.SerializationError{Err: err}
3486	}
3487
3488	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3489		return out, metadata, &smithy.SerializationError{Err: err}
3490	}
3491	in.Request = request
3492
3493	return next.HandleSerialize(ctx, in)
3494}
3495func awsRestjson1_serializeOpHttpBindingsDescribeIAMPolicyAssignmentInput(v *DescribeIAMPolicyAssignmentInput, encoder *httpbinding.Encoder) error {
3496	if v == nil {
3497		return fmt.Errorf("unsupported serialization of nil %T", v)
3498	}
3499
3500	if v.AssignmentName == nil || len(*v.AssignmentName) == 0 {
3501		return &smithy.SerializationError{Err: fmt.Errorf("input member AssignmentName must not be empty")}
3502	}
3503	if v.AssignmentName != nil {
3504		if err := encoder.SetURI("AssignmentName").String(*v.AssignmentName); err != nil {
3505			return err
3506		}
3507	}
3508
3509	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3510		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3511	}
3512	if v.AwsAccountId != nil {
3513		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3514			return err
3515		}
3516	}
3517
3518	if v.Namespace == nil || len(*v.Namespace) == 0 {
3519		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
3520	}
3521	if v.Namespace != nil {
3522		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
3523			return err
3524		}
3525	}
3526
3527	return nil
3528}
3529
3530type awsRestjson1_serializeOpDescribeIngestion struct {
3531}
3532
3533func (*awsRestjson1_serializeOpDescribeIngestion) ID() string {
3534	return "OperationSerializer"
3535}
3536
3537func (m *awsRestjson1_serializeOpDescribeIngestion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3538	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3539) {
3540	request, ok := in.Request.(*smithyhttp.Request)
3541	if !ok {
3542		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3543	}
3544
3545	input, ok := in.Parameters.(*DescribeIngestionInput)
3546	_ = input
3547	if !ok {
3548		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3549	}
3550
3551	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions/{IngestionId}")
3552	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3553	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3554	request.Method = "GET"
3555	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3556	if err != nil {
3557		return out, metadata, &smithy.SerializationError{Err: err}
3558	}
3559
3560	if err := awsRestjson1_serializeOpHttpBindingsDescribeIngestionInput(input, restEncoder); err != nil {
3561		return out, metadata, &smithy.SerializationError{Err: err}
3562	}
3563
3564	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3565		return out, metadata, &smithy.SerializationError{Err: err}
3566	}
3567	in.Request = request
3568
3569	return next.HandleSerialize(ctx, in)
3570}
3571func awsRestjson1_serializeOpHttpBindingsDescribeIngestionInput(v *DescribeIngestionInput, encoder *httpbinding.Encoder) error {
3572	if v == nil {
3573		return fmt.Errorf("unsupported serialization of nil %T", v)
3574	}
3575
3576	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3577		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3578	}
3579	if v.AwsAccountId != nil {
3580		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3581			return err
3582		}
3583	}
3584
3585	if v.DataSetId == nil || len(*v.DataSetId) == 0 {
3586		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")}
3587	}
3588	if v.DataSetId != nil {
3589		if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil {
3590			return err
3591		}
3592	}
3593
3594	if v.IngestionId == nil || len(*v.IngestionId) == 0 {
3595		return &smithy.SerializationError{Err: fmt.Errorf("input member IngestionId must not be empty")}
3596	}
3597	if v.IngestionId != nil {
3598		if err := encoder.SetURI("IngestionId").String(*v.IngestionId); err != nil {
3599			return err
3600		}
3601	}
3602
3603	return nil
3604}
3605
3606type awsRestjson1_serializeOpDescribeNamespace struct {
3607}
3608
3609func (*awsRestjson1_serializeOpDescribeNamespace) ID() string {
3610	return "OperationSerializer"
3611}
3612
3613func (m *awsRestjson1_serializeOpDescribeNamespace) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3614	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3615) {
3616	request, ok := in.Request.(*smithyhttp.Request)
3617	if !ok {
3618		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3619	}
3620
3621	input, ok := in.Parameters.(*DescribeNamespaceInput)
3622	_ = input
3623	if !ok {
3624		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3625	}
3626
3627	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}")
3628	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3629	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3630	request.Method = "GET"
3631	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3632	if err != nil {
3633		return out, metadata, &smithy.SerializationError{Err: err}
3634	}
3635
3636	if err := awsRestjson1_serializeOpHttpBindingsDescribeNamespaceInput(input, restEncoder); err != nil {
3637		return out, metadata, &smithy.SerializationError{Err: err}
3638	}
3639
3640	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3641		return out, metadata, &smithy.SerializationError{Err: err}
3642	}
3643	in.Request = request
3644
3645	return next.HandleSerialize(ctx, in)
3646}
3647func awsRestjson1_serializeOpHttpBindingsDescribeNamespaceInput(v *DescribeNamespaceInput, encoder *httpbinding.Encoder) error {
3648	if v == nil {
3649		return fmt.Errorf("unsupported serialization of nil %T", v)
3650	}
3651
3652	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3653		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3654	}
3655	if v.AwsAccountId != nil {
3656		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3657			return err
3658		}
3659	}
3660
3661	if v.Namespace == nil || len(*v.Namespace) == 0 {
3662		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
3663	}
3664	if v.Namespace != nil {
3665		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
3666			return err
3667		}
3668	}
3669
3670	return nil
3671}
3672
3673type awsRestjson1_serializeOpDescribeTemplate struct {
3674}
3675
3676func (*awsRestjson1_serializeOpDescribeTemplate) ID() string {
3677	return "OperationSerializer"
3678}
3679
3680func (m *awsRestjson1_serializeOpDescribeTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3681	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3682) {
3683	request, ok := in.Request.(*smithyhttp.Request)
3684	if !ok {
3685		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3686	}
3687
3688	input, ok := in.Parameters.(*DescribeTemplateInput)
3689	_ = input
3690	if !ok {
3691		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3692	}
3693
3694	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}")
3695	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3696	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3697	request.Method = "GET"
3698	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3699	if err != nil {
3700		return out, metadata, &smithy.SerializationError{Err: err}
3701	}
3702
3703	if err := awsRestjson1_serializeOpHttpBindingsDescribeTemplateInput(input, restEncoder); err != nil {
3704		return out, metadata, &smithy.SerializationError{Err: err}
3705	}
3706
3707	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3708		return out, metadata, &smithy.SerializationError{Err: err}
3709	}
3710	in.Request = request
3711
3712	return next.HandleSerialize(ctx, in)
3713}
3714func awsRestjson1_serializeOpHttpBindingsDescribeTemplateInput(v *DescribeTemplateInput, encoder *httpbinding.Encoder) error {
3715	if v == nil {
3716		return fmt.Errorf("unsupported serialization of nil %T", v)
3717	}
3718
3719	if v.AliasName != nil {
3720		encoder.SetQuery("alias-name").String(*v.AliasName)
3721	}
3722
3723	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3724		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3725	}
3726	if v.AwsAccountId != nil {
3727		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3728			return err
3729		}
3730	}
3731
3732	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
3733		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
3734	}
3735	if v.TemplateId != nil {
3736		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
3737			return err
3738		}
3739	}
3740
3741	if v.VersionNumber != nil {
3742		encoder.SetQuery("version-number").Long(*v.VersionNumber)
3743	}
3744
3745	return nil
3746}
3747
3748type awsRestjson1_serializeOpDescribeTemplateAlias struct {
3749}
3750
3751func (*awsRestjson1_serializeOpDescribeTemplateAlias) ID() string {
3752	return "OperationSerializer"
3753}
3754
3755func (m *awsRestjson1_serializeOpDescribeTemplateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3756	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3757) {
3758	request, ok := in.Request.(*smithyhttp.Request)
3759	if !ok {
3760		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3761	}
3762
3763	input, ok := in.Parameters.(*DescribeTemplateAliasInput)
3764	_ = input
3765	if !ok {
3766		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3767	}
3768
3769	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}")
3770	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3771	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3772	request.Method = "GET"
3773	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3774	if err != nil {
3775		return out, metadata, &smithy.SerializationError{Err: err}
3776	}
3777
3778	if err := awsRestjson1_serializeOpHttpBindingsDescribeTemplateAliasInput(input, restEncoder); err != nil {
3779		return out, metadata, &smithy.SerializationError{Err: err}
3780	}
3781
3782	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3783		return out, metadata, &smithy.SerializationError{Err: err}
3784	}
3785	in.Request = request
3786
3787	return next.HandleSerialize(ctx, in)
3788}
3789func awsRestjson1_serializeOpHttpBindingsDescribeTemplateAliasInput(v *DescribeTemplateAliasInput, encoder *httpbinding.Encoder) error {
3790	if v == nil {
3791		return fmt.Errorf("unsupported serialization of nil %T", v)
3792	}
3793
3794	if v.AliasName == nil || len(*v.AliasName) == 0 {
3795		return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")}
3796	}
3797	if v.AliasName != nil {
3798		if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil {
3799			return err
3800		}
3801	}
3802
3803	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3804		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3805	}
3806	if v.AwsAccountId != nil {
3807		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3808			return err
3809		}
3810	}
3811
3812	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
3813		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
3814	}
3815	if v.TemplateId != nil {
3816		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
3817			return err
3818		}
3819	}
3820
3821	return nil
3822}
3823
3824type awsRestjson1_serializeOpDescribeTemplatePermissions struct {
3825}
3826
3827func (*awsRestjson1_serializeOpDescribeTemplatePermissions) ID() string {
3828	return "OperationSerializer"
3829}
3830
3831func (m *awsRestjson1_serializeOpDescribeTemplatePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3832	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3833) {
3834	request, ok := in.Request.(*smithyhttp.Request)
3835	if !ok {
3836		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3837	}
3838
3839	input, ok := in.Parameters.(*DescribeTemplatePermissionsInput)
3840	_ = input
3841	if !ok {
3842		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3843	}
3844
3845	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/permissions")
3846	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3847	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3848	request.Method = "GET"
3849	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3850	if err != nil {
3851		return out, metadata, &smithy.SerializationError{Err: err}
3852	}
3853
3854	if err := awsRestjson1_serializeOpHttpBindingsDescribeTemplatePermissionsInput(input, restEncoder); err != nil {
3855		return out, metadata, &smithy.SerializationError{Err: err}
3856	}
3857
3858	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3859		return out, metadata, &smithy.SerializationError{Err: err}
3860	}
3861	in.Request = request
3862
3863	return next.HandleSerialize(ctx, in)
3864}
3865func awsRestjson1_serializeOpHttpBindingsDescribeTemplatePermissionsInput(v *DescribeTemplatePermissionsInput, encoder *httpbinding.Encoder) error {
3866	if v == nil {
3867		return fmt.Errorf("unsupported serialization of nil %T", v)
3868	}
3869
3870	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3871		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3872	}
3873	if v.AwsAccountId != nil {
3874		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3875			return err
3876		}
3877	}
3878
3879	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
3880		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
3881	}
3882	if v.TemplateId != nil {
3883		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
3884			return err
3885		}
3886	}
3887
3888	return nil
3889}
3890
3891type awsRestjson1_serializeOpDescribeTheme struct {
3892}
3893
3894func (*awsRestjson1_serializeOpDescribeTheme) ID() string {
3895	return "OperationSerializer"
3896}
3897
3898func (m *awsRestjson1_serializeOpDescribeTheme) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3899	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3900) {
3901	request, ok := in.Request.(*smithyhttp.Request)
3902	if !ok {
3903		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3904	}
3905
3906	input, ok := in.Parameters.(*DescribeThemeInput)
3907	_ = input
3908	if !ok {
3909		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3910	}
3911
3912	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}")
3913	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3914	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3915	request.Method = "GET"
3916	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3917	if err != nil {
3918		return out, metadata, &smithy.SerializationError{Err: err}
3919	}
3920
3921	if err := awsRestjson1_serializeOpHttpBindingsDescribeThemeInput(input, restEncoder); err != nil {
3922		return out, metadata, &smithy.SerializationError{Err: err}
3923	}
3924
3925	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
3926		return out, metadata, &smithy.SerializationError{Err: err}
3927	}
3928	in.Request = request
3929
3930	return next.HandleSerialize(ctx, in)
3931}
3932func awsRestjson1_serializeOpHttpBindingsDescribeThemeInput(v *DescribeThemeInput, encoder *httpbinding.Encoder) error {
3933	if v == nil {
3934		return fmt.Errorf("unsupported serialization of nil %T", v)
3935	}
3936
3937	if v.AliasName != nil {
3938		encoder.SetQuery("alias-name").String(*v.AliasName)
3939	}
3940
3941	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
3942		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
3943	}
3944	if v.AwsAccountId != nil {
3945		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
3946			return err
3947		}
3948	}
3949
3950	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
3951		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
3952	}
3953	if v.ThemeId != nil {
3954		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
3955			return err
3956		}
3957	}
3958
3959	if v.VersionNumber != nil {
3960		encoder.SetQuery("version-number").Long(*v.VersionNumber)
3961	}
3962
3963	return nil
3964}
3965
3966type awsRestjson1_serializeOpDescribeThemeAlias struct {
3967}
3968
3969func (*awsRestjson1_serializeOpDescribeThemeAlias) ID() string {
3970	return "OperationSerializer"
3971}
3972
3973func (m *awsRestjson1_serializeOpDescribeThemeAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
3974	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
3975) {
3976	request, ok := in.Request.(*smithyhttp.Request)
3977	if !ok {
3978		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
3979	}
3980
3981	input, ok := in.Parameters.(*DescribeThemeAliasInput)
3982	_ = input
3983	if !ok {
3984		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
3985	}
3986
3987	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}")
3988	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
3989	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
3990	request.Method = "GET"
3991	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
3992	if err != nil {
3993		return out, metadata, &smithy.SerializationError{Err: err}
3994	}
3995
3996	if err := awsRestjson1_serializeOpHttpBindingsDescribeThemeAliasInput(input, restEncoder); err != nil {
3997		return out, metadata, &smithy.SerializationError{Err: err}
3998	}
3999
4000	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4001		return out, metadata, &smithy.SerializationError{Err: err}
4002	}
4003	in.Request = request
4004
4005	return next.HandleSerialize(ctx, in)
4006}
4007func awsRestjson1_serializeOpHttpBindingsDescribeThemeAliasInput(v *DescribeThemeAliasInput, encoder *httpbinding.Encoder) error {
4008	if v == nil {
4009		return fmt.Errorf("unsupported serialization of nil %T", v)
4010	}
4011
4012	if v.AliasName == nil || len(*v.AliasName) == 0 {
4013		return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")}
4014	}
4015	if v.AliasName != nil {
4016		if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil {
4017			return err
4018		}
4019	}
4020
4021	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4022		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4023	}
4024	if v.AwsAccountId != nil {
4025		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4026			return err
4027		}
4028	}
4029
4030	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
4031		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
4032	}
4033	if v.ThemeId != nil {
4034		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
4035			return err
4036		}
4037	}
4038
4039	return nil
4040}
4041
4042type awsRestjson1_serializeOpDescribeThemePermissions struct {
4043}
4044
4045func (*awsRestjson1_serializeOpDescribeThemePermissions) ID() string {
4046	return "OperationSerializer"
4047}
4048
4049func (m *awsRestjson1_serializeOpDescribeThemePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4050	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4051) {
4052	request, ok := in.Request.(*smithyhttp.Request)
4053	if !ok {
4054		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4055	}
4056
4057	input, ok := in.Parameters.(*DescribeThemePermissionsInput)
4058	_ = input
4059	if !ok {
4060		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4061	}
4062
4063	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/permissions")
4064	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4065	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4066	request.Method = "GET"
4067	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4068	if err != nil {
4069		return out, metadata, &smithy.SerializationError{Err: err}
4070	}
4071
4072	if err := awsRestjson1_serializeOpHttpBindingsDescribeThemePermissionsInput(input, restEncoder); err != nil {
4073		return out, metadata, &smithy.SerializationError{Err: err}
4074	}
4075
4076	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4077		return out, metadata, &smithy.SerializationError{Err: err}
4078	}
4079	in.Request = request
4080
4081	return next.HandleSerialize(ctx, in)
4082}
4083func awsRestjson1_serializeOpHttpBindingsDescribeThemePermissionsInput(v *DescribeThemePermissionsInput, encoder *httpbinding.Encoder) error {
4084	if v == nil {
4085		return fmt.Errorf("unsupported serialization of nil %T", v)
4086	}
4087
4088	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4089		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4090	}
4091	if v.AwsAccountId != nil {
4092		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4093			return err
4094		}
4095	}
4096
4097	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
4098		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
4099	}
4100	if v.ThemeId != nil {
4101		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
4102			return err
4103		}
4104	}
4105
4106	return nil
4107}
4108
4109type awsRestjson1_serializeOpDescribeUser struct {
4110}
4111
4112func (*awsRestjson1_serializeOpDescribeUser) ID() string {
4113	return "OperationSerializer"
4114}
4115
4116func (m *awsRestjson1_serializeOpDescribeUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4117	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4118) {
4119	request, ok := in.Request.(*smithyhttp.Request)
4120	if !ok {
4121		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4122	}
4123
4124	input, ok := in.Parameters.(*DescribeUserInput)
4125	_ = input
4126	if !ok {
4127		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4128	}
4129
4130	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}")
4131	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4132	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4133	request.Method = "GET"
4134	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4135	if err != nil {
4136		return out, metadata, &smithy.SerializationError{Err: err}
4137	}
4138
4139	if err := awsRestjson1_serializeOpHttpBindingsDescribeUserInput(input, restEncoder); err != nil {
4140		return out, metadata, &smithy.SerializationError{Err: err}
4141	}
4142
4143	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4144		return out, metadata, &smithy.SerializationError{Err: err}
4145	}
4146	in.Request = request
4147
4148	return next.HandleSerialize(ctx, in)
4149}
4150func awsRestjson1_serializeOpHttpBindingsDescribeUserInput(v *DescribeUserInput, encoder *httpbinding.Encoder) error {
4151	if v == nil {
4152		return fmt.Errorf("unsupported serialization of nil %T", v)
4153	}
4154
4155	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4156		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4157	}
4158	if v.AwsAccountId != nil {
4159		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4160			return err
4161		}
4162	}
4163
4164	if v.Namespace == nil || len(*v.Namespace) == 0 {
4165		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
4166	}
4167	if v.Namespace != nil {
4168		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
4169			return err
4170		}
4171	}
4172
4173	if v.UserName == nil || len(*v.UserName) == 0 {
4174		return &smithy.SerializationError{Err: fmt.Errorf("input member UserName must not be empty")}
4175	}
4176	if v.UserName != nil {
4177		if err := encoder.SetURI("UserName").String(*v.UserName); err != nil {
4178			return err
4179		}
4180	}
4181
4182	return nil
4183}
4184
4185type awsRestjson1_serializeOpGetDashboardEmbedUrl struct {
4186}
4187
4188func (*awsRestjson1_serializeOpGetDashboardEmbedUrl) ID() string {
4189	return "OperationSerializer"
4190}
4191
4192func (m *awsRestjson1_serializeOpGetDashboardEmbedUrl) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4193	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4194) {
4195	request, ok := in.Request.(*smithyhttp.Request)
4196	if !ok {
4197		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4198	}
4199
4200	input, ok := in.Parameters.(*GetDashboardEmbedUrlInput)
4201	_ = input
4202	if !ok {
4203		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4204	}
4205
4206	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}/embed-url")
4207	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4208	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4209	request.Method = "GET"
4210	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4211	if err != nil {
4212		return out, metadata, &smithy.SerializationError{Err: err}
4213	}
4214
4215	if err := awsRestjson1_serializeOpHttpBindingsGetDashboardEmbedUrlInput(input, restEncoder); err != nil {
4216		return out, metadata, &smithy.SerializationError{Err: err}
4217	}
4218
4219	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4220		return out, metadata, &smithy.SerializationError{Err: err}
4221	}
4222	in.Request = request
4223
4224	return next.HandleSerialize(ctx, in)
4225}
4226func awsRestjson1_serializeOpHttpBindingsGetDashboardEmbedUrlInput(v *GetDashboardEmbedUrlInput, encoder *httpbinding.Encoder) error {
4227	if v == nil {
4228		return fmt.Errorf("unsupported serialization of nil %T", v)
4229	}
4230
4231	if v.AdditionalDashboardIds != nil {
4232		for i := range v.AdditionalDashboardIds {
4233			encoder.AddQuery("additional-dashboard-ids").String(v.AdditionalDashboardIds[i])
4234		}
4235	}
4236
4237	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4238		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4239	}
4240	if v.AwsAccountId != nil {
4241		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4242			return err
4243		}
4244	}
4245
4246	if v.DashboardId == nil || len(*v.DashboardId) == 0 {
4247		return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")}
4248	}
4249	if v.DashboardId != nil {
4250		if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil {
4251			return err
4252		}
4253	}
4254
4255	if len(v.IdentityType) > 0 {
4256		encoder.SetQuery("creds-type").String(string(v.IdentityType))
4257	}
4258
4259	if v.Namespace != nil {
4260		encoder.SetQuery("namespace").String(*v.Namespace)
4261	}
4262
4263	if v.ResetDisabled {
4264		encoder.SetQuery("reset-disabled").Boolean(v.ResetDisabled)
4265	}
4266
4267	if v.SessionLifetimeInMinutes != nil {
4268		encoder.SetQuery("session-lifetime").Long(*v.SessionLifetimeInMinutes)
4269	}
4270
4271	if v.StatePersistenceEnabled {
4272		encoder.SetQuery("state-persistence-enabled").Boolean(v.StatePersistenceEnabled)
4273	}
4274
4275	if v.UndoRedoDisabled {
4276		encoder.SetQuery("undo-redo-disabled").Boolean(v.UndoRedoDisabled)
4277	}
4278
4279	if v.UserArn != nil {
4280		encoder.SetQuery("user-arn").String(*v.UserArn)
4281	}
4282
4283	return nil
4284}
4285
4286type awsRestjson1_serializeOpGetSessionEmbedUrl struct {
4287}
4288
4289func (*awsRestjson1_serializeOpGetSessionEmbedUrl) ID() string {
4290	return "OperationSerializer"
4291}
4292
4293func (m *awsRestjson1_serializeOpGetSessionEmbedUrl) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4294	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4295) {
4296	request, ok := in.Request.(*smithyhttp.Request)
4297	if !ok {
4298		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4299	}
4300
4301	input, ok := in.Parameters.(*GetSessionEmbedUrlInput)
4302	_ = input
4303	if !ok {
4304		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4305	}
4306
4307	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/session-embed-url")
4308	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4309	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4310	request.Method = "GET"
4311	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4312	if err != nil {
4313		return out, metadata, &smithy.SerializationError{Err: err}
4314	}
4315
4316	if err := awsRestjson1_serializeOpHttpBindingsGetSessionEmbedUrlInput(input, restEncoder); err != nil {
4317		return out, metadata, &smithy.SerializationError{Err: err}
4318	}
4319
4320	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4321		return out, metadata, &smithy.SerializationError{Err: err}
4322	}
4323	in.Request = request
4324
4325	return next.HandleSerialize(ctx, in)
4326}
4327func awsRestjson1_serializeOpHttpBindingsGetSessionEmbedUrlInput(v *GetSessionEmbedUrlInput, encoder *httpbinding.Encoder) error {
4328	if v == nil {
4329		return fmt.Errorf("unsupported serialization of nil %T", v)
4330	}
4331
4332	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4333		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4334	}
4335	if v.AwsAccountId != nil {
4336		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4337			return err
4338		}
4339	}
4340
4341	if v.EntryPoint != nil {
4342		encoder.SetQuery("entry-point").String(*v.EntryPoint)
4343	}
4344
4345	if v.SessionLifetimeInMinutes != nil {
4346		encoder.SetQuery("session-lifetime").Long(*v.SessionLifetimeInMinutes)
4347	}
4348
4349	if v.UserArn != nil {
4350		encoder.SetQuery("user-arn").String(*v.UserArn)
4351	}
4352
4353	return nil
4354}
4355
4356type awsRestjson1_serializeOpListAnalyses struct {
4357}
4358
4359func (*awsRestjson1_serializeOpListAnalyses) ID() string {
4360	return "OperationSerializer"
4361}
4362
4363func (m *awsRestjson1_serializeOpListAnalyses) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4364	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4365) {
4366	request, ok := in.Request.(*smithyhttp.Request)
4367	if !ok {
4368		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4369	}
4370
4371	input, ok := in.Parameters.(*ListAnalysesInput)
4372	_ = input
4373	if !ok {
4374		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4375	}
4376
4377	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses")
4378	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4379	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4380	request.Method = "GET"
4381	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4382	if err != nil {
4383		return out, metadata, &smithy.SerializationError{Err: err}
4384	}
4385
4386	if err := awsRestjson1_serializeOpHttpBindingsListAnalysesInput(input, restEncoder); err != nil {
4387		return out, metadata, &smithy.SerializationError{Err: err}
4388	}
4389
4390	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4391		return out, metadata, &smithy.SerializationError{Err: err}
4392	}
4393	in.Request = request
4394
4395	return next.HandleSerialize(ctx, in)
4396}
4397func awsRestjson1_serializeOpHttpBindingsListAnalysesInput(v *ListAnalysesInput, encoder *httpbinding.Encoder) error {
4398	if v == nil {
4399		return fmt.Errorf("unsupported serialization of nil %T", v)
4400	}
4401
4402	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4403		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4404	}
4405	if v.AwsAccountId != nil {
4406		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4407			return err
4408		}
4409	}
4410
4411	if v.MaxResults != 0 {
4412		encoder.SetQuery("max-results").Integer(v.MaxResults)
4413	}
4414
4415	if v.NextToken != nil {
4416		encoder.SetQuery("next-token").String(*v.NextToken)
4417	}
4418
4419	return nil
4420}
4421
4422type awsRestjson1_serializeOpListDashboards struct {
4423}
4424
4425func (*awsRestjson1_serializeOpListDashboards) ID() string {
4426	return "OperationSerializer"
4427}
4428
4429func (m *awsRestjson1_serializeOpListDashboards) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4430	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4431) {
4432	request, ok := in.Request.(*smithyhttp.Request)
4433	if !ok {
4434		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4435	}
4436
4437	input, ok := in.Parameters.(*ListDashboardsInput)
4438	_ = input
4439	if !ok {
4440		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4441	}
4442
4443	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards")
4444	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4445	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4446	request.Method = "GET"
4447	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4448	if err != nil {
4449		return out, metadata, &smithy.SerializationError{Err: err}
4450	}
4451
4452	if err := awsRestjson1_serializeOpHttpBindingsListDashboardsInput(input, restEncoder); err != nil {
4453		return out, metadata, &smithy.SerializationError{Err: err}
4454	}
4455
4456	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4457		return out, metadata, &smithy.SerializationError{Err: err}
4458	}
4459	in.Request = request
4460
4461	return next.HandleSerialize(ctx, in)
4462}
4463func awsRestjson1_serializeOpHttpBindingsListDashboardsInput(v *ListDashboardsInput, encoder *httpbinding.Encoder) error {
4464	if v == nil {
4465		return fmt.Errorf("unsupported serialization of nil %T", v)
4466	}
4467
4468	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4469		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4470	}
4471	if v.AwsAccountId != nil {
4472		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4473			return err
4474		}
4475	}
4476
4477	if v.MaxResults != 0 {
4478		encoder.SetQuery("max-results").Integer(v.MaxResults)
4479	}
4480
4481	if v.NextToken != nil {
4482		encoder.SetQuery("next-token").String(*v.NextToken)
4483	}
4484
4485	return nil
4486}
4487
4488type awsRestjson1_serializeOpListDashboardVersions struct {
4489}
4490
4491func (*awsRestjson1_serializeOpListDashboardVersions) ID() string {
4492	return "OperationSerializer"
4493}
4494
4495func (m *awsRestjson1_serializeOpListDashboardVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4496	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4497) {
4498	request, ok := in.Request.(*smithyhttp.Request)
4499	if !ok {
4500		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4501	}
4502
4503	input, ok := in.Parameters.(*ListDashboardVersionsInput)
4504	_ = input
4505	if !ok {
4506		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4507	}
4508
4509	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}/versions")
4510	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4511	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4512	request.Method = "GET"
4513	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4514	if err != nil {
4515		return out, metadata, &smithy.SerializationError{Err: err}
4516	}
4517
4518	if err := awsRestjson1_serializeOpHttpBindingsListDashboardVersionsInput(input, restEncoder); err != nil {
4519		return out, metadata, &smithy.SerializationError{Err: err}
4520	}
4521
4522	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4523		return out, metadata, &smithy.SerializationError{Err: err}
4524	}
4525	in.Request = request
4526
4527	return next.HandleSerialize(ctx, in)
4528}
4529func awsRestjson1_serializeOpHttpBindingsListDashboardVersionsInput(v *ListDashboardVersionsInput, encoder *httpbinding.Encoder) error {
4530	if v == nil {
4531		return fmt.Errorf("unsupported serialization of nil %T", v)
4532	}
4533
4534	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4535		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4536	}
4537	if v.AwsAccountId != nil {
4538		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4539			return err
4540		}
4541	}
4542
4543	if v.DashboardId == nil || len(*v.DashboardId) == 0 {
4544		return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")}
4545	}
4546	if v.DashboardId != nil {
4547		if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil {
4548			return err
4549		}
4550	}
4551
4552	if v.MaxResults != 0 {
4553		encoder.SetQuery("max-results").Integer(v.MaxResults)
4554	}
4555
4556	if v.NextToken != nil {
4557		encoder.SetQuery("next-token").String(*v.NextToken)
4558	}
4559
4560	return nil
4561}
4562
4563type awsRestjson1_serializeOpListDataSets struct {
4564}
4565
4566func (*awsRestjson1_serializeOpListDataSets) ID() string {
4567	return "OperationSerializer"
4568}
4569
4570func (m *awsRestjson1_serializeOpListDataSets) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4571	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4572) {
4573	request, ok := in.Request.(*smithyhttp.Request)
4574	if !ok {
4575		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4576	}
4577
4578	input, ok := in.Parameters.(*ListDataSetsInput)
4579	_ = input
4580	if !ok {
4581		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4582	}
4583
4584	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets")
4585	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4586	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4587	request.Method = "GET"
4588	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4589	if err != nil {
4590		return out, metadata, &smithy.SerializationError{Err: err}
4591	}
4592
4593	if err := awsRestjson1_serializeOpHttpBindingsListDataSetsInput(input, restEncoder); err != nil {
4594		return out, metadata, &smithy.SerializationError{Err: err}
4595	}
4596
4597	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4598		return out, metadata, &smithy.SerializationError{Err: err}
4599	}
4600	in.Request = request
4601
4602	return next.HandleSerialize(ctx, in)
4603}
4604func awsRestjson1_serializeOpHttpBindingsListDataSetsInput(v *ListDataSetsInput, encoder *httpbinding.Encoder) error {
4605	if v == nil {
4606		return fmt.Errorf("unsupported serialization of nil %T", v)
4607	}
4608
4609	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4610		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4611	}
4612	if v.AwsAccountId != nil {
4613		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4614			return err
4615		}
4616	}
4617
4618	if v.MaxResults != 0 {
4619		encoder.SetQuery("max-results").Integer(v.MaxResults)
4620	}
4621
4622	if v.NextToken != nil {
4623		encoder.SetQuery("next-token").String(*v.NextToken)
4624	}
4625
4626	return nil
4627}
4628
4629type awsRestjson1_serializeOpListDataSources struct {
4630}
4631
4632func (*awsRestjson1_serializeOpListDataSources) ID() string {
4633	return "OperationSerializer"
4634}
4635
4636func (m *awsRestjson1_serializeOpListDataSources) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4637	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4638) {
4639	request, ok := in.Request.(*smithyhttp.Request)
4640	if !ok {
4641		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4642	}
4643
4644	input, ok := in.Parameters.(*ListDataSourcesInput)
4645	_ = input
4646	if !ok {
4647		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4648	}
4649
4650	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources")
4651	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4652	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4653	request.Method = "GET"
4654	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4655	if err != nil {
4656		return out, metadata, &smithy.SerializationError{Err: err}
4657	}
4658
4659	if err := awsRestjson1_serializeOpHttpBindingsListDataSourcesInput(input, restEncoder); err != nil {
4660		return out, metadata, &smithy.SerializationError{Err: err}
4661	}
4662
4663	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4664		return out, metadata, &smithy.SerializationError{Err: err}
4665	}
4666	in.Request = request
4667
4668	return next.HandleSerialize(ctx, in)
4669}
4670func awsRestjson1_serializeOpHttpBindingsListDataSourcesInput(v *ListDataSourcesInput, encoder *httpbinding.Encoder) error {
4671	if v == nil {
4672		return fmt.Errorf("unsupported serialization of nil %T", v)
4673	}
4674
4675	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4676		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4677	}
4678	if v.AwsAccountId != nil {
4679		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4680			return err
4681		}
4682	}
4683
4684	if v.MaxResults != 0 {
4685		encoder.SetQuery("max-results").Integer(v.MaxResults)
4686	}
4687
4688	if v.NextToken != nil {
4689		encoder.SetQuery("next-token").String(*v.NextToken)
4690	}
4691
4692	return nil
4693}
4694
4695type awsRestjson1_serializeOpListGroupMemberships struct {
4696}
4697
4698func (*awsRestjson1_serializeOpListGroupMemberships) ID() string {
4699	return "OperationSerializer"
4700}
4701
4702func (m *awsRestjson1_serializeOpListGroupMemberships) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4703	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4704) {
4705	request, ok := in.Request.(*smithyhttp.Request)
4706	if !ok {
4707		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4708	}
4709
4710	input, ok := in.Parameters.(*ListGroupMembershipsInput)
4711	_ = input
4712	if !ok {
4713		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4714	}
4715
4716	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}/members")
4717	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4718	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4719	request.Method = "GET"
4720	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4721	if err != nil {
4722		return out, metadata, &smithy.SerializationError{Err: err}
4723	}
4724
4725	if err := awsRestjson1_serializeOpHttpBindingsListGroupMembershipsInput(input, restEncoder); err != nil {
4726		return out, metadata, &smithy.SerializationError{Err: err}
4727	}
4728
4729	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4730		return out, metadata, &smithy.SerializationError{Err: err}
4731	}
4732	in.Request = request
4733
4734	return next.HandleSerialize(ctx, in)
4735}
4736func awsRestjson1_serializeOpHttpBindingsListGroupMembershipsInput(v *ListGroupMembershipsInput, encoder *httpbinding.Encoder) error {
4737	if v == nil {
4738		return fmt.Errorf("unsupported serialization of nil %T", v)
4739	}
4740
4741	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4742		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4743	}
4744	if v.AwsAccountId != nil {
4745		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4746			return err
4747		}
4748	}
4749
4750	if v.GroupName == nil || len(*v.GroupName) == 0 {
4751		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")}
4752	}
4753	if v.GroupName != nil {
4754		if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil {
4755			return err
4756		}
4757	}
4758
4759	if v.MaxResults != 0 {
4760		encoder.SetQuery("max-results").Integer(v.MaxResults)
4761	}
4762
4763	if v.Namespace == nil || len(*v.Namespace) == 0 {
4764		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
4765	}
4766	if v.Namespace != nil {
4767		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
4768			return err
4769		}
4770	}
4771
4772	if v.NextToken != nil {
4773		encoder.SetQuery("next-token").String(*v.NextToken)
4774	}
4775
4776	return nil
4777}
4778
4779type awsRestjson1_serializeOpListGroups struct {
4780}
4781
4782func (*awsRestjson1_serializeOpListGroups) ID() string {
4783	return "OperationSerializer"
4784}
4785
4786func (m *awsRestjson1_serializeOpListGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4787	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4788) {
4789	request, ok := in.Request.(*smithyhttp.Request)
4790	if !ok {
4791		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4792	}
4793
4794	input, ok := in.Parameters.(*ListGroupsInput)
4795	_ = input
4796	if !ok {
4797		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4798	}
4799
4800	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups")
4801	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4802	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4803	request.Method = "GET"
4804	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4805	if err != nil {
4806		return out, metadata, &smithy.SerializationError{Err: err}
4807	}
4808
4809	if err := awsRestjson1_serializeOpHttpBindingsListGroupsInput(input, restEncoder); err != nil {
4810		return out, metadata, &smithy.SerializationError{Err: err}
4811	}
4812
4813	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4814		return out, metadata, &smithy.SerializationError{Err: err}
4815	}
4816	in.Request = request
4817
4818	return next.HandleSerialize(ctx, in)
4819}
4820func awsRestjson1_serializeOpHttpBindingsListGroupsInput(v *ListGroupsInput, encoder *httpbinding.Encoder) error {
4821	if v == nil {
4822		return fmt.Errorf("unsupported serialization of nil %T", v)
4823	}
4824
4825	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4826		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4827	}
4828	if v.AwsAccountId != nil {
4829		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4830			return err
4831		}
4832	}
4833
4834	if v.MaxResults != 0 {
4835		encoder.SetQuery("max-results").Integer(v.MaxResults)
4836	}
4837
4838	if v.Namespace == nil || len(*v.Namespace) == 0 {
4839		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
4840	}
4841	if v.Namespace != nil {
4842		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
4843			return err
4844		}
4845	}
4846
4847	if v.NextToken != nil {
4848		encoder.SetQuery("next-token").String(*v.NextToken)
4849	}
4850
4851	return nil
4852}
4853
4854type awsRestjson1_serializeOpListIAMPolicyAssignments struct {
4855}
4856
4857func (*awsRestjson1_serializeOpListIAMPolicyAssignments) ID() string {
4858	return "OperationSerializer"
4859}
4860
4861func (m *awsRestjson1_serializeOpListIAMPolicyAssignments) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4862	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4863) {
4864	request, ok := in.Request.(*smithyhttp.Request)
4865	if !ok {
4866		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4867	}
4868
4869	input, ok := in.Parameters.(*ListIAMPolicyAssignmentsInput)
4870	_ = input
4871	if !ok {
4872		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4873	}
4874
4875	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments")
4876	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4877	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4878	request.Method = "GET"
4879	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4880	if err != nil {
4881		return out, metadata, &smithy.SerializationError{Err: err}
4882	}
4883
4884	if err := awsRestjson1_serializeOpHttpBindingsListIAMPolicyAssignmentsInput(input, restEncoder); err != nil {
4885		return out, metadata, &smithy.SerializationError{Err: err}
4886	}
4887
4888	restEncoder.SetHeader("Content-Type").String("application/json")
4889
4890	jsonEncoder := smithyjson.NewEncoder()
4891	if err := awsRestjson1_serializeOpDocumentListIAMPolicyAssignmentsInput(input, jsonEncoder.Value); err != nil {
4892		return out, metadata, &smithy.SerializationError{Err: err}
4893	}
4894
4895	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
4896		return out, metadata, &smithy.SerializationError{Err: err}
4897	}
4898
4899	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4900		return out, metadata, &smithy.SerializationError{Err: err}
4901	}
4902	in.Request = request
4903
4904	return next.HandleSerialize(ctx, in)
4905}
4906func awsRestjson1_serializeOpHttpBindingsListIAMPolicyAssignmentsInput(v *ListIAMPolicyAssignmentsInput, encoder *httpbinding.Encoder) error {
4907	if v == nil {
4908		return fmt.Errorf("unsupported serialization of nil %T", v)
4909	}
4910
4911	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4912		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
4913	}
4914	if v.AwsAccountId != nil {
4915		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
4916			return err
4917		}
4918	}
4919
4920	if v.MaxResults != 0 {
4921		encoder.SetQuery("max-results").Integer(v.MaxResults)
4922	}
4923
4924	if v.Namespace == nil || len(*v.Namespace) == 0 {
4925		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
4926	}
4927	if v.Namespace != nil {
4928		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
4929			return err
4930		}
4931	}
4932
4933	if v.NextToken != nil {
4934		encoder.SetQuery("next-token").String(*v.NextToken)
4935	}
4936
4937	return nil
4938}
4939
4940func awsRestjson1_serializeOpDocumentListIAMPolicyAssignmentsInput(v *ListIAMPolicyAssignmentsInput, value smithyjson.Value) error {
4941	object := value.Object()
4942	defer object.Close()
4943
4944	if len(v.AssignmentStatus) > 0 {
4945		ok := object.Key("AssignmentStatus")
4946		ok.String(string(v.AssignmentStatus))
4947	}
4948
4949	return nil
4950}
4951
4952type awsRestjson1_serializeOpListIAMPolicyAssignmentsForUser struct {
4953}
4954
4955func (*awsRestjson1_serializeOpListIAMPolicyAssignmentsForUser) ID() string {
4956	return "OperationSerializer"
4957}
4958
4959func (m *awsRestjson1_serializeOpListIAMPolicyAssignmentsForUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
4960	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
4961) {
4962	request, ok := in.Request.(*smithyhttp.Request)
4963	if !ok {
4964		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
4965	}
4966
4967	input, ok := in.Parameters.(*ListIAMPolicyAssignmentsForUserInput)
4968	_ = input
4969	if !ok {
4970		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
4971	}
4972
4973	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}/iam-policy-assignments")
4974	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
4975	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
4976	request.Method = "GET"
4977	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
4978	if err != nil {
4979		return out, metadata, &smithy.SerializationError{Err: err}
4980	}
4981
4982	if err := awsRestjson1_serializeOpHttpBindingsListIAMPolicyAssignmentsForUserInput(input, restEncoder); err != nil {
4983		return out, metadata, &smithy.SerializationError{Err: err}
4984	}
4985
4986	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
4987		return out, metadata, &smithy.SerializationError{Err: err}
4988	}
4989	in.Request = request
4990
4991	return next.HandleSerialize(ctx, in)
4992}
4993func awsRestjson1_serializeOpHttpBindingsListIAMPolicyAssignmentsForUserInput(v *ListIAMPolicyAssignmentsForUserInput, encoder *httpbinding.Encoder) error {
4994	if v == nil {
4995		return fmt.Errorf("unsupported serialization of nil %T", v)
4996	}
4997
4998	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
4999		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5000	}
5001	if v.AwsAccountId != nil {
5002		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5003			return err
5004		}
5005	}
5006
5007	if v.MaxResults != 0 {
5008		encoder.SetQuery("max-results").Integer(v.MaxResults)
5009	}
5010
5011	if v.Namespace == nil || len(*v.Namespace) == 0 {
5012		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
5013	}
5014	if v.Namespace != nil {
5015		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
5016			return err
5017		}
5018	}
5019
5020	if v.NextToken != nil {
5021		encoder.SetQuery("next-token").String(*v.NextToken)
5022	}
5023
5024	if v.UserName == nil || len(*v.UserName) == 0 {
5025		return &smithy.SerializationError{Err: fmt.Errorf("input member UserName must not be empty")}
5026	}
5027	if v.UserName != nil {
5028		if err := encoder.SetURI("UserName").String(*v.UserName); err != nil {
5029			return err
5030		}
5031	}
5032
5033	return nil
5034}
5035
5036type awsRestjson1_serializeOpListIngestions struct {
5037}
5038
5039func (*awsRestjson1_serializeOpListIngestions) ID() string {
5040	return "OperationSerializer"
5041}
5042
5043func (m *awsRestjson1_serializeOpListIngestions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5044	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5045) {
5046	request, ok := in.Request.(*smithyhttp.Request)
5047	if !ok {
5048		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5049	}
5050
5051	input, ok := in.Parameters.(*ListIngestionsInput)
5052	_ = input
5053	if !ok {
5054		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5055	}
5056
5057	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/ingestions")
5058	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5059	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5060	request.Method = "GET"
5061	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5062	if err != nil {
5063		return out, metadata, &smithy.SerializationError{Err: err}
5064	}
5065
5066	if err := awsRestjson1_serializeOpHttpBindingsListIngestionsInput(input, restEncoder); err != nil {
5067		return out, metadata, &smithy.SerializationError{Err: err}
5068	}
5069
5070	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5071		return out, metadata, &smithy.SerializationError{Err: err}
5072	}
5073	in.Request = request
5074
5075	return next.HandleSerialize(ctx, in)
5076}
5077func awsRestjson1_serializeOpHttpBindingsListIngestionsInput(v *ListIngestionsInput, encoder *httpbinding.Encoder) error {
5078	if v == nil {
5079		return fmt.Errorf("unsupported serialization of nil %T", v)
5080	}
5081
5082	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
5083		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5084	}
5085	if v.AwsAccountId != nil {
5086		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5087			return err
5088		}
5089	}
5090
5091	if v.DataSetId == nil || len(*v.DataSetId) == 0 {
5092		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")}
5093	}
5094	if v.DataSetId != nil {
5095		if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil {
5096			return err
5097		}
5098	}
5099
5100	if v.MaxResults != 0 {
5101		encoder.SetQuery("max-results").Integer(v.MaxResults)
5102	}
5103
5104	if v.NextToken != nil {
5105		encoder.SetQuery("next-token").String(*v.NextToken)
5106	}
5107
5108	return nil
5109}
5110
5111type awsRestjson1_serializeOpListNamespaces struct {
5112}
5113
5114func (*awsRestjson1_serializeOpListNamespaces) ID() string {
5115	return "OperationSerializer"
5116}
5117
5118func (m *awsRestjson1_serializeOpListNamespaces) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5119	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5120) {
5121	request, ok := in.Request.(*smithyhttp.Request)
5122	if !ok {
5123		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5124	}
5125
5126	input, ok := in.Parameters.(*ListNamespacesInput)
5127	_ = input
5128	if !ok {
5129		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5130	}
5131
5132	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces")
5133	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5134	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5135	request.Method = "GET"
5136	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5137	if err != nil {
5138		return out, metadata, &smithy.SerializationError{Err: err}
5139	}
5140
5141	if err := awsRestjson1_serializeOpHttpBindingsListNamespacesInput(input, restEncoder); err != nil {
5142		return out, metadata, &smithy.SerializationError{Err: err}
5143	}
5144
5145	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5146		return out, metadata, &smithy.SerializationError{Err: err}
5147	}
5148	in.Request = request
5149
5150	return next.HandleSerialize(ctx, in)
5151}
5152func awsRestjson1_serializeOpHttpBindingsListNamespacesInput(v *ListNamespacesInput, encoder *httpbinding.Encoder) error {
5153	if v == nil {
5154		return fmt.Errorf("unsupported serialization of nil %T", v)
5155	}
5156
5157	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
5158		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5159	}
5160	if v.AwsAccountId != nil {
5161		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5162			return err
5163		}
5164	}
5165
5166	if v.MaxResults != 0 {
5167		encoder.SetQuery("max-results").Integer(v.MaxResults)
5168	}
5169
5170	if v.NextToken != nil {
5171		encoder.SetQuery("next-token").String(*v.NextToken)
5172	}
5173
5174	return nil
5175}
5176
5177type awsRestjson1_serializeOpListTagsForResource struct {
5178}
5179
5180func (*awsRestjson1_serializeOpListTagsForResource) ID() string {
5181	return "OperationSerializer"
5182}
5183
5184func (m *awsRestjson1_serializeOpListTagsForResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5185	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5186) {
5187	request, ok := in.Request.(*smithyhttp.Request)
5188	if !ok {
5189		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5190	}
5191
5192	input, ok := in.Parameters.(*ListTagsForResourceInput)
5193	_ = input
5194	if !ok {
5195		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5196	}
5197
5198	opPath, opQuery := httpbinding.SplitURI("/resources/{ResourceArn}/tags")
5199	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5200	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5201	request.Method = "GET"
5202	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5203	if err != nil {
5204		return out, metadata, &smithy.SerializationError{Err: err}
5205	}
5206
5207	if err := awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(input, restEncoder); err != nil {
5208		return out, metadata, &smithy.SerializationError{Err: err}
5209	}
5210
5211	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5212		return out, metadata, &smithy.SerializationError{Err: err}
5213	}
5214	in.Request = request
5215
5216	return next.HandleSerialize(ctx, in)
5217}
5218func awsRestjson1_serializeOpHttpBindingsListTagsForResourceInput(v *ListTagsForResourceInput, encoder *httpbinding.Encoder) error {
5219	if v == nil {
5220		return fmt.Errorf("unsupported serialization of nil %T", v)
5221	}
5222
5223	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
5224		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
5225	}
5226	if v.ResourceArn != nil {
5227		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
5228			return err
5229		}
5230	}
5231
5232	return nil
5233}
5234
5235type awsRestjson1_serializeOpListTemplateAliases struct {
5236}
5237
5238func (*awsRestjson1_serializeOpListTemplateAliases) ID() string {
5239	return "OperationSerializer"
5240}
5241
5242func (m *awsRestjson1_serializeOpListTemplateAliases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5243	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5244) {
5245	request, ok := in.Request.(*smithyhttp.Request)
5246	if !ok {
5247		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5248	}
5249
5250	input, ok := in.Parameters.(*ListTemplateAliasesInput)
5251	_ = input
5252	if !ok {
5253		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5254	}
5255
5256	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/aliases")
5257	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5258	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5259	request.Method = "GET"
5260	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5261	if err != nil {
5262		return out, metadata, &smithy.SerializationError{Err: err}
5263	}
5264
5265	if err := awsRestjson1_serializeOpHttpBindingsListTemplateAliasesInput(input, restEncoder); err != nil {
5266		return out, metadata, &smithy.SerializationError{Err: err}
5267	}
5268
5269	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5270		return out, metadata, &smithy.SerializationError{Err: err}
5271	}
5272	in.Request = request
5273
5274	return next.HandleSerialize(ctx, in)
5275}
5276func awsRestjson1_serializeOpHttpBindingsListTemplateAliasesInput(v *ListTemplateAliasesInput, encoder *httpbinding.Encoder) error {
5277	if v == nil {
5278		return fmt.Errorf("unsupported serialization of nil %T", v)
5279	}
5280
5281	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
5282		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5283	}
5284	if v.AwsAccountId != nil {
5285		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5286			return err
5287		}
5288	}
5289
5290	if v.MaxResults != 0 {
5291		encoder.SetQuery("max-result").Integer(v.MaxResults)
5292	}
5293
5294	if v.NextToken != nil {
5295		encoder.SetQuery("next-token").String(*v.NextToken)
5296	}
5297
5298	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
5299		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
5300	}
5301	if v.TemplateId != nil {
5302		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
5303			return err
5304		}
5305	}
5306
5307	return nil
5308}
5309
5310type awsRestjson1_serializeOpListTemplates struct {
5311}
5312
5313func (*awsRestjson1_serializeOpListTemplates) ID() string {
5314	return "OperationSerializer"
5315}
5316
5317func (m *awsRestjson1_serializeOpListTemplates) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5318	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5319) {
5320	request, ok := in.Request.(*smithyhttp.Request)
5321	if !ok {
5322		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5323	}
5324
5325	input, ok := in.Parameters.(*ListTemplatesInput)
5326	_ = input
5327	if !ok {
5328		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5329	}
5330
5331	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates")
5332	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5333	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5334	request.Method = "GET"
5335	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5336	if err != nil {
5337		return out, metadata, &smithy.SerializationError{Err: err}
5338	}
5339
5340	if err := awsRestjson1_serializeOpHttpBindingsListTemplatesInput(input, restEncoder); err != nil {
5341		return out, metadata, &smithy.SerializationError{Err: err}
5342	}
5343
5344	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5345		return out, metadata, &smithy.SerializationError{Err: err}
5346	}
5347	in.Request = request
5348
5349	return next.HandleSerialize(ctx, in)
5350}
5351func awsRestjson1_serializeOpHttpBindingsListTemplatesInput(v *ListTemplatesInput, encoder *httpbinding.Encoder) error {
5352	if v == nil {
5353		return fmt.Errorf("unsupported serialization of nil %T", v)
5354	}
5355
5356	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
5357		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5358	}
5359	if v.AwsAccountId != nil {
5360		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5361			return err
5362		}
5363	}
5364
5365	if v.MaxResults != 0 {
5366		encoder.SetQuery("max-result").Integer(v.MaxResults)
5367	}
5368
5369	if v.NextToken != nil {
5370		encoder.SetQuery("next-token").String(*v.NextToken)
5371	}
5372
5373	return nil
5374}
5375
5376type awsRestjson1_serializeOpListTemplateVersions struct {
5377}
5378
5379func (*awsRestjson1_serializeOpListTemplateVersions) ID() string {
5380	return "OperationSerializer"
5381}
5382
5383func (m *awsRestjson1_serializeOpListTemplateVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5384	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5385) {
5386	request, ok := in.Request.(*smithyhttp.Request)
5387	if !ok {
5388		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5389	}
5390
5391	input, ok := in.Parameters.(*ListTemplateVersionsInput)
5392	_ = input
5393	if !ok {
5394		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5395	}
5396
5397	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/versions")
5398	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5399	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5400	request.Method = "GET"
5401	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5402	if err != nil {
5403		return out, metadata, &smithy.SerializationError{Err: err}
5404	}
5405
5406	if err := awsRestjson1_serializeOpHttpBindingsListTemplateVersionsInput(input, restEncoder); err != nil {
5407		return out, metadata, &smithy.SerializationError{Err: err}
5408	}
5409
5410	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5411		return out, metadata, &smithy.SerializationError{Err: err}
5412	}
5413	in.Request = request
5414
5415	return next.HandleSerialize(ctx, in)
5416}
5417func awsRestjson1_serializeOpHttpBindingsListTemplateVersionsInput(v *ListTemplateVersionsInput, encoder *httpbinding.Encoder) error {
5418	if v == nil {
5419		return fmt.Errorf("unsupported serialization of nil %T", v)
5420	}
5421
5422	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
5423		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5424	}
5425	if v.AwsAccountId != nil {
5426		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5427			return err
5428		}
5429	}
5430
5431	if v.MaxResults != 0 {
5432		encoder.SetQuery("max-results").Integer(v.MaxResults)
5433	}
5434
5435	if v.NextToken != nil {
5436		encoder.SetQuery("next-token").String(*v.NextToken)
5437	}
5438
5439	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
5440		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
5441	}
5442	if v.TemplateId != nil {
5443		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
5444			return err
5445		}
5446	}
5447
5448	return nil
5449}
5450
5451type awsRestjson1_serializeOpListThemeAliases struct {
5452}
5453
5454func (*awsRestjson1_serializeOpListThemeAliases) ID() string {
5455	return "OperationSerializer"
5456}
5457
5458func (m *awsRestjson1_serializeOpListThemeAliases) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5459	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5460) {
5461	request, ok := in.Request.(*smithyhttp.Request)
5462	if !ok {
5463		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5464	}
5465
5466	input, ok := in.Parameters.(*ListThemeAliasesInput)
5467	_ = input
5468	if !ok {
5469		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5470	}
5471
5472	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/aliases")
5473	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5474	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5475	request.Method = "GET"
5476	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5477	if err != nil {
5478		return out, metadata, &smithy.SerializationError{Err: err}
5479	}
5480
5481	if err := awsRestjson1_serializeOpHttpBindingsListThemeAliasesInput(input, restEncoder); err != nil {
5482		return out, metadata, &smithy.SerializationError{Err: err}
5483	}
5484
5485	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5486		return out, metadata, &smithy.SerializationError{Err: err}
5487	}
5488	in.Request = request
5489
5490	return next.HandleSerialize(ctx, in)
5491}
5492func awsRestjson1_serializeOpHttpBindingsListThemeAliasesInput(v *ListThemeAliasesInput, encoder *httpbinding.Encoder) error {
5493	if v == nil {
5494		return fmt.Errorf("unsupported serialization of nil %T", v)
5495	}
5496
5497	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
5498		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5499	}
5500	if v.AwsAccountId != nil {
5501		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5502			return err
5503		}
5504	}
5505
5506	if v.MaxResults != 0 {
5507		encoder.SetQuery("max-result").Integer(v.MaxResults)
5508	}
5509
5510	if v.NextToken != nil {
5511		encoder.SetQuery("next-token").String(*v.NextToken)
5512	}
5513
5514	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
5515		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
5516	}
5517	if v.ThemeId != nil {
5518		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
5519			return err
5520		}
5521	}
5522
5523	return nil
5524}
5525
5526type awsRestjson1_serializeOpListThemes struct {
5527}
5528
5529func (*awsRestjson1_serializeOpListThemes) ID() string {
5530	return "OperationSerializer"
5531}
5532
5533func (m *awsRestjson1_serializeOpListThemes) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5534	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5535) {
5536	request, ok := in.Request.(*smithyhttp.Request)
5537	if !ok {
5538		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5539	}
5540
5541	input, ok := in.Parameters.(*ListThemesInput)
5542	_ = input
5543	if !ok {
5544		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5545	}
5546
5547	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes")
5548	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5549	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5550	request.Method = "GET"
5551	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5552	if err != nil {
5553		return out, metadata, &smithy.SerializationError{Err: err}
5554	}
5555
5556	if err := awsRestjson1_serializeOpHttpBindingsListThemesInput(input, restEncoder); err != nil {
5557		return out, metadata, &smithy.SerializationError{Err: err}
5558	}
5559
5560	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5561		return out, metadata, &smithy.SerializationError{Err: err}
5562	}
5563	in.Request = request
5564
5565	return next.HandleSerialize(ctx, in)
5566}
5567func awsRestjson1_serializeOpHttpBindingsListThemesInput(v *ListThemesInput, encoder *httpbinding.Encoder) error {
5568	if v == nil {
5569		return fmt.Errorf("unsupported serialization of nil %T", v)
5570	}
5571
5572	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
5573		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5574	}
5575	if v.AwsAccountId != nil {
5576		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5577			return err
5578		}
5579	}
5580
5581	if v.MaxResults != 0 {
5582		encoder.SetQuery("max-results").Integer(v.MaxResults)
5583	}
5584
5585	if v.NextToken != nil {
5586		encoder.SetQuery("next-token").String(*v.NextToken)
5587	}
5588
5589	if len(v.Type) > 0 {
5590		encoder.SetQuery("type").String(string(v.Type))
5591	}
5592
5593	return nil
5594}
5595
5596type awsRestjson1_serializeOpListThemeVersions struct {
5597}
5598
5599func (*awsRestjson1_serializeOpListThemeVersions) ID() string {
5600	return "OperationSerializer"
5601}
5602
5603func (m *awsRestjson1_serializeOpListThemeVersions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5604	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5605) {
5606	request, ok := in.Request.(*smithyhttp.Request)
5607	if !ok {
5608		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5609	}
5610
5611	input, ok := in.Parameters.(*ListThemeVersionsInput)
5612	_ = input
5613	if !ok {
5614		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5615	}
5616
5617	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/versions")
5618	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5619	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5620	request.Method = "GET"
5621	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5622	if err != nil {
5623		return out, metadata, &smithy.SerializationError{Err: err}
5624	}
5625
5626	if err := awsRestjson1_serializeOpHttpBindingsListThemeVersionsInput(input, restEncoder); err != nil {
5627		return out, metadata, &smithy.SerializationError{Err: err}
5628	}
5629
5630	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5631		return out, metadata, &smithy.SerializationError{Err: err}
5632	}
5633	in.Request = request
5634
5635	return next.HandleSerialize(ctx, in)
5636}
5637func awsRestjson1_serializeOpHttpBindingsListThemeVersionsInput(v *ListThemeVersionsInput, encoder *httpbinding.Encoder) error {
5638	if v == nil {
5639		return fmt.Errorf("unsupported serialization of nil %T", v)
5640	}
5641
5642	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
5643		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5644	}
5645	if v.AwsAccountId != nil {
5646		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5647			return err
5648		}
5649	}
5650
5651	if v.MaxResults != 0 {
5652		encoder.SetQuery("max-results").Integer(v.MaxResults)
5653	}
5654
5655	if v.NextToken != nil {
5656		encoder.SetQuery("next-token").String(*v.NextToken)
5657	}
5658
5659	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
5660		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
5661	}
5662	if v.ThemeId != nil {
5663		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
5664			return err
5665		}
5666	}
5667
5668	return nil
5669}
5670
5671type awsRestjson1_serializeOpListUserGroups struct {
5672}
5673
5674func (*awsRestjson1_serializeOpListUserGroups) ID() string {
5675	return "OperationSerializer"
5676}
5677
5678func (m *awsRestjson1_serializeOpListUserGroups) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5679	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5680) {
5681	request, ok := in.Request.(*smithyhttp.Request)
5682	if !ok {
5683		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5684	}
5685
5686	input, ok := in.Parameters.(*ListUserGroupsInput)
5687	_ = input
5688	if !ok {
5689		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5690	}
5691
5692	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}/groups")
5693	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5694	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5695	request.Method = "GET"
5696	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5697	if err != nil {
5698		return out, metadata, &smithy.SerializationError{Err: err}
5699	}
5700
5701	if err := awsRestjson1_serializeOpHttpBindingsListUserGroupsInput(input, restEncoder); err != nil {
5702		return out, metadata, &smithy.SerializationError{Err: err}
5703	}
5704
5705	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5706		return out, metadata, &smithy.SerializationError{Err: err}
5707	}
5708	in.Request = request
5709
5710	return next.HandleSerialize(ctx, in)
5711}
5712func awsRestjson1_serializeOpHttpBindingsListUserGroupsInput(v *ListUserGroupsInput, encoder *httpbinding.Encoder) error {
5713	if v == nil {
5714		return fmt.Errorf("unsupported serialization of nil %T", v)
5715	}
5716
5717	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
5718		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5719	}
5720	if v.AwsAccountId != nil {
5721		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5722			return err
5723		}
5724	}
5725
5726	if v.MaxResults != 0 {
5727		encoder.SetQuery("max-results").Integer(v.MaxResults)
5728	}
5729
5730	if v.Namespace == nil || len(*v.Namespace) == 0 {
5731		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
5732	}
5733	if v.Namespace != nil {
5734		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
5735			return err
5736		}
5737	}
5738
5739	if v.NextToken != nil {
5740		encoder.SetQuery("next-token").String(*v.NextToken)
5741	}
5742
5743	if v.UserName == nil || len(*v.UserName) == 0 {
5744		return &smithy.SerializationError{Err: fmt.Errorf("input member UserName must not be empty")}
5745	}
5746	if v.UserName != nil {
5747		if err := encoder.SetURI("UserName").String(*v.UserName); err != nil {
5748			return err
5749		}
5750	}
5751
5752	return nil
5753}
5754
5755type awsRestjson1_serializeOpListUsers struct {
5756}
5757
5758func (*awsRestjson1_serializeOpListUsers) ID() string {
5759	return "OperationSerializer"
5760}
5761
5762func (m *awsRestjson1_serializeOpListUsers) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5763	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5764) {
5765	request, ok := in.Request.(*smithyhttp.Request)
5766	if !ok {
5767		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5768	}
5769
5770	input, ok := in.Parameters.(*ListUsersInput)
5771	_ = input
5772	if !ok {
5773		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5774	}
5775
5776	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users")
5777	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5778	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5779	request.Method = "GET"
5780	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5781	if err != nil {
5782		return out, metadata, &smithy.SerializationError{Err: err}
5783	}
5784
5785	if err := awsRestjson1_serializeOpHttpBindingsListUsersInput(input, restEncoder); err != nil {
5786		return out, metadata, &smithy.SerializationError{Err: err}
5787	}
5788
5789	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5790		return out, metadata, &smithy.SerializationError{Err: err}
5791	}
5792	in.Request = request
5793
5794	return next.HandleSerialize(ctx, in)
5795}
5796func awsRestjson1_serializeOpHttpBindingsListUsersInput(v *ListUsersInput, encoder *httpbinding.Encoder) error {
5797	if v == nil {
5798		return fmt.Errorf("unsupported serialization of nil %T", v)
5799	}
5800
5801	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
5802		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5803	}
5804	if v.AwsAccountId != nil {
5805		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5806			return err
5807		}
5808	}
5809
5810	if v.MaxResults != 0 {
5811		encoder.SetQuery("max-results").Integer(v.MaxResults)
5812	}
5813
5814	if v.Namespace == nil || len(*v.Namespace) == 0 {
5815		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
5816	}
5817	if v.Namespace != nil {
5818		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
5819			return err
5820		}
5821	}
5822
5823	if v.NextToken != nil {
5824		encoder.SetQuery("next-token").String(*v.NextToken)
5825	}
5826
5827	return nil
5828}
5829
5830type awsRestjson1_serializeOpRegisterUser struct {
5831}
5832
5833func (*awsRestjson1_serializeOpRegisterUser) ID() string {
5834	return "OperationSerializer"
5835}
5836
5837func (m *awsRestjson1_serializeOpRegisterUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5838	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5839) {
5840	request, ok := in.Request.(*smithyhttp.Request)
5841	if !ok {
5842		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5843	}
5844
5845	input, ok := in.Parameters.(*RegisterUserInput)
5846	_ = input
5847	if !ok {
5848		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5849	}
5850
5851	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users")
5852	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5853	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5854	request.Method = "POST"
5855	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5856	if err != nil {
5857		return out, metadata, &smithy.SerializationError{Err: err}
5858	}
5859
5860	if err := awsRestjson1_serializeOpHttpBindingsRegisterUserInput(input, restEncoder); err != nil {
5861		return out, metadata, &smithy.SerializationError{Err: err}
5862	}
5863
5864	restEncoder.SetHeader("Content-Type").String("application/json")
5865
5866	jsonEncoder := smithyjson.NewEncoder()
5867	if err := awsRestjson1_serializeOpDocumentRegisterUserInput(input, jsonEncoder.Value); err != nil {
5868		return out, metadata, &smithy.SerializationError{Err: err}
5869	}
5870
5871	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
5872		return out, metadata, &smithy.SerializationError{Err: err}
5873	}
5874
5875	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5876		return out, metadata, &smithy.SerializationError{Err: err}
5877	}
5878	in.Request = request
5879
5880	return next.HandleSerialize(ctx, in)
5881}
5882func awsRestjson1_serializeOpHttpBindingsRegisterUserInput(v *RegisterUserInput, encoder *httpbinding.Encoder) error {
5883	if v == nil {
5884		return fmt.Errorf("unsupported serialization of nil %T", v)
5885	}
5886
5887	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
5888		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
5889	}
5890	if v.AwsAccountId != nil {
5891		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
5892			return err
5893		}
5894	}
5895
5896	if v.Namespace == nil || len(*v.Namespace) == 0 {
5897		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
5898	}
5899	if v.Namespace != nil {
5900		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
5901			return err
5902		}
5903	}
5904
5905	return nil
5906}
5907
5908func awsRestjson1_serializeOpDocumentRegisterUserInput(v *RegisterUserInput, value smithyjson.Value) error {
5909	object := value.Object()
5910	defer object.Close()
5911
5912	if v.CustomPermissionsName != nil {
5913		ok := object.Key("CustomPermissionsName")
5914		ok.String(*v.CustomPermissionsName)
5915	}
5916
5917	if v.Email != nil {
5918		ok := object.Key("Email")
5919		ok.String(*v.Email)
5920	}
5921
5922	if v.IamArn != nil {
5923		ok := object.Key("IamArn")
5924		ok.String(*v.IamArn)
5925	}
5926
5927	if len(v.IdentityType) > 0 {
5928		ok := object.Key("IdentityType")
5929		ok.String(string(v.IdentityType))
5930	}
5931
5932	if v.SessionName != nil {
5933		ok := object.Key("SessionName")
5934		ok.String(*v.SessionName)
5935	}
5936
5937	if v.UserName != nil {
5938		ok := object.Key("UserName")
5939		ok.String(*v.UserName)
5940	}
5941
5942	if len(v.UserRole) > 0 {
5943		ok := object.Key("UserRole")
5944		ok.String(string(v.UserRole))
5945	}
5946
5947	return nil
5948}
5949
5950type awsRestjson1_serializeOpRestoreAnalysis struct {
5951}
5952
5953func (*awsRestjson1_serializeOpRestoreAnalysis) ID() string {
5954	return "OperationSerializer"
5955}
5956
5957func (m *awsRestjson1_serializeOpRestoreAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
5958	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
5959) {
5960	request, ok := in.Request.(*smithyhttp.Request)
5961	if !ok {
5962		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
5963	}
5964
5965	input, ok := in.Parameters.(*RestoreAnalysisInput)
5966	_ = input
5967	if !ok {
5968		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
5969	}
5970
5971	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/restore/analyses/{AnalysisId}")
5972	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
5973	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
5974	request.Method = "POST"
5975	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
5976	if err != nil {
5977		return out, metadata, &smithy.SerializationError{Err: err}
5978	}
5979
5980	if err := awsRestjson1_serializeOpHttpBindingsRestoreAnalysisInput(input, restEncoder); err != nil {
5981		return out, metadata, &smithy.SerializationError{Err: err}
5982	}
5983
5984	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
5985		return out, metadata, &smithy.SerializationError{Err: err}
5986	}
5987	in.Request = request
5988
5989	return next.HandleSerialize(ctx, in)
5990}
5991func awsRestjson1_serializeOpHttpBindingsRestoreAnalysisInput(v *RestoreAnalysisInput, encoder *httpbinding.Encoder) error {
5992	if v == nil {
5993		return fmt.Errorf("unsupported serialization of nil %T", v)
5994	}
5995
5996	if v.AnalysisId == nil || len(*v.AnalysisId) == 0 {
5997		return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")}
5998	}
5999	if v.AnalysisId != nil {
6000		if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil {
6001			return err
6002		}
6003	}
6004
6005	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
6006		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
6007	}
6008	if v.AwsAccountId != nil {
6009		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
6010			return err
6011		}
6012	}
6013
6014	return nil
6015}
6016
6017type awsRestjson1_serializeOpSearchAnalyses struct {
6018}
6019
6020func (*awsRestjson1_serializeOpSearchAnalyses) ID() string {
6021	return "OperationSerializer"
6022}
6023
6024func (m *awsRestjson1_serializeOpSearchAnalyses) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6025	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6026) {
6027	request, ok := in.Request.(*smithyhttp.Request)
6028	if !ok {
6029		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6030	}
6031
6032	input, ok := in.Parameters.(*SearchAnalysesInput)
6033	_ = input
6034	if !ok {
6035		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6036	}
6037
6038	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/search/analyses")
6039	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6040	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6041	request.Method = "POST"
6042	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6043	if err != nil {
6044		return out, metadata, &smithy.SerializationError{Err: err}
6045	}
6046
6047	if err := awsRestjson1_serializeOpHttpBindingsSearchAnalysesInput(input, restEncoder); err != nil {
6048		return out, metadata, &smithy.SerializationError{Err: err}
6049	}
6050
6051	restEncoder.SetHeader("Content-Type").String("application/json")
6052
6053	jsonEncoder := smithyjson.NewEncoder()
6054	if err := awsRestjson1_serializeOpDocumentSearchAnalysesInput(input, jsonEncoder.Value); err != nil {
6055		return out, metadata, &smithy.SerializationError{Err: err}
6056	}
6057
6058	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6059		return out, metadata, &smithy.SerializationError{Err: err}
6060	}
6061
6062	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6063		return out, metadata, &smithy.SerializationError{Err: err}
6064	}
6065	in.Request = request
6066
6067	return next.HandleSerialize(ctx, in)
6068}
6069func awsRestjson1_serializeOpHttpBindingsSearchAnalysesInput(v *SearchAnalysesInput, encoder *httpbinding.Encoder) error {
6070	if v == nil {
6071		return fmt.Errorf("unsupported serialization of nil %T", v)
6072	}
6073
6074	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
6075		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
6076	}
6077	if v.AwsAccountId != nil {
6078		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
6079			return err
6080		}
6081	}
6082
6083	return nil
6084}
6085
6086func awsRestjson1_serializeOpDocumentSearchAnalysesInput(v *SearchAnalysesInput, value smithyjson.Value) error {
6087	object := value.Object()
6088	defer object.Close()
6089
6090	if v.Filters != nil {
6091		ok := object.Key("Filters")
6092		if err := awsRestjson1_serializeDocumentAnalysisSearchFilterList(v.Filters, ok); err != nil {
6093			return err
6094		}
6095	}
6096
6097	if v.MaxResults != 0 {
6098		ok := object.Key("MaxResults")
6099		ok.Integer(v.MaxResults)
6100	}
6101
6102	if v.NextToken != nil {
6103		ok := object.Key("NextToken")
6104		ok.String(*v.NextToken)
6105	}
6106
6107	return nil
6108}
6109
6110type awsRestjson1_serializeOpSearchDashboards struct {
6111}
6112
6113func (*awsRestjson1_serializeOpSearchDashboards) ID() string {
6114	return "OperationSerializer"
6115}
6116
6117func (m *awsRestjson1_serializeOpSearchDashboards) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6118	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6119) {
6120	request, ok := in.Request.(*smithyhttp.Request)
6121	if !ok {
6122		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6123	}
6124
6125	input, ok := in.Parameters.(*SearchDashboardsInput)
6126	_ = input
6127	if !ok {
6128		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6129	}
6130
6131	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/search/dashboards")
6132	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6133	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6134	request.Method = "POST"
6135	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6136	if err != nil {
6137		return out, metadata, &smithy.SerializationError{Err: err}
6138	}
6139
6140	if err := awsRestjson1_serializeOpHttpBindingsSearchDashboardsInput(input, restEncoder); err != nil {
6141		return out, metadata, &smithy.SerializationError{Err: err}
6142	}
6143
6144	restEncoder.SetHeader("Content-Type").String("application/json")
6145
6146	jsonEncoder := smithyjson.NewEncoder()
6147	if err := awsRestjson1_serializeOpDocumentSearchDashboardsInput(input, jsonEncoder.Value); err != nil {
6148		return out, metadata, &smithy.SerializationError{Err: err}
6149	}
6150
6151	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6152		return out, metadata, &smithy.SerializationError{Err: err}
6153	}
6154
6155	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6156		return out, metadata, &smithy.SerializationError{Err: err}
6157	}
6158	in.Request = request
6159
6160	return next.HandleSerialize(ctx, in)
6161}
6162func awsRestjson1_serializeOpHttpBindingsSearchDashboardsInput(v *SearchDashboardsInput, encoder *httpbinding.Encoder) error {
6163	if v == nil {
6164		return fmt.Errorf("unsupported serialization of nil %T", v)
6165	}
6166
6167	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
6168		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
6169	}
6170	if v.AwsAccountId != nil {
6171		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
6172			return err
6173		}
6174	}
6175
6176	return nil
6177}
6178
6179func awsRestjson1_serializeOpDocumentSearchDashboardsInput(v *SearchDashboardsInput, value smithyjson.Value) error {
6180	object := value.Object()
6181	defer object.Close()
6182
6183	if v.Filters != nil {
6184		ok := object.Key("Filters")
6185		if err := awsRestjson1_serializeDocumentDashboardSearchFilterList(v.Filters, ok); err != nil {
6186			return err
6187		}
6188	}
6189
6190	if v.MaxResults != 0 {
6191		ok := object.Key("MaxResults")
6192		ok.Integer(v.MaxResults)
6193	}
6194
6195	if v.NextToken != nil {
6196		ok := object.Key("NextToken")
6197		ok.String(*v.NextToken)
6198	}
6199
6200	return nil
6201}
6202
6203type awsRestjson1_serializeOpTagResource struct {
6204}
6205
6206func (*awsRestjson1_serializeOpTagResource) ID() string {
6207	return "OperationSerializer"
6208}
6209
6210func (m *awsRestjson1_serializeOpTagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6211	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6212) {
6213	request, ok := in.Request.(*smithyhttp.Request)
6214	if !ok {
6215		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6216	}
6217
6218	input, ok := in.Parameters.(*TagResourceInput)
6219	_ = input
6220	if !ok {
6221		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6222	}
6223
6224	opPath, opQuery := httpbinding.SplitURI("/resources/{ResourceArn}/tags")
6225	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6226	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6227	request.Method = "POST"
6228	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6229	if err != nil {
6230		return out, metadata, &smithy.SerializationError{Err: err}
6231	}
6232
6233	if err := awsRestjson1_serializeOpHttpBindingsTagResourceInput(input, restEncoder); err != nil {
6234		return out, metadata, &smithy.SerializationError{Err: err}
6235	}
6236
6237	restEncoder.SetHeader("Content-Type").String("application/json")
6238
6239	jsonEncoder := smithyjson.NewEncoder()
6240	if err := awsRestjson1_serializeOpDocumentTagResourceInput(input, jsonEncoder.Value); err != nil {
6241		return out, metadata, &smithy.SerializationError{Err: err}
6242	}
6243
6244	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6245		return out, metadata, &smithy.SerializationError{Err: err}
6246	}
6247
6248	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6249		return out, metadata, &smithy.SerializationError{Err: err}
6250	}
6251	in.Request = request
6252
6253	return next.HandleSerialize(ctx, in)
6254}
6255func awsRestjson1_serializeOpHttpBindingsTagResourceInput(v *TagResourceInput, encoder *httpbinding.Encoder) error {
6256	if v == nil {
6257		return fmt.Errorf("unsupported serialization of nil %T", v)
6258	}
6259
6260	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
6261		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
6262	}
6263	if v.ResourceArn != nil {
6264		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
6265			return err
6266		}
6267	}
6268
6269	return nil
6270}
6271
6272func awsRestjson1_serializeOpDocumentTagResourceInput(v *TagResourceInput, value smithyjson.Value) error {
6273	object := value.Object()
6274	defer object.Close()
6275
6276	if v.Tags != nil {
6277		ok := object.Key("Tags")
6278		if err := awsRestjson1_serializeDocumentTagList(v.Tags, ok); err != nil {
6279			return err
6280		}
6281	}
6282
6283	return nil
6284}
6285
6286type awsRestjson1_serializeOpUntagResource struct {
6287}
6288
6289func (*awsRestjson1_serializeOpUntagResource) ID() string {
6290	return "OperationSerializer"
6291}
6292
6293func (m *awsRestjson1_serializeOpUntagResource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6294	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6295) {
6296	request, ok := in.Request.(*smithyhttp.Request)
6297	if !ok {
6298		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6299	}
6300
6301	input, ok := in.Parameters.(*UntagResourceInput)
6302	_ = input
6303	if !ok {
6304		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6305	}
6306
6307	opPath, opQuery := httpbinding.SplitURI("/resources/{ResourceArn}/tags")
6308	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6309	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6310	request.Method = "DELETE"
6311	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6312	if err != nil {
6313		return out, metadata, &smithy.SerializationError{Err: err}
6314	}
6315
6316	if err := awsRestjson1_serializeOpHttpBindingsUntagResourceInput(input, restEncoder); err != nil {
6317		return out, metadata, &smithy.SerializationError{Err: err}
6318	}
6319
6320	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6321		return out, metadata, &smithy.SerializationError{Err: err}
6322	}
6323	in.Request = request
6324
6325	return next.HandleSerialize(ctx, in)
6326}
6327func awsRestjson1_serializeOpHttpBindingsUntagResourceInput(v *UntagResourceInput, encoder *httpbinding.Encoder) error {
6328	if v == nil {
6329		return fmt.Errorf("unsupported serialization of nil %T", v)
6330	}
6331
6332	if v.ResourceArn == nil || len(*v.ResourceArn) == 0 {
6333		return &smithy.SerializationError{Err: fmt.Errorf("input member ResourceArn must not be empty")}
6334	}
6335	if v.ResourceArn != nil {
6336		if err := encoder.SetURI("ResourceArn").String(*v.ResourceArn); err != nil {
6337			return err
6338		}
6339	}
6340
6341	if v.TagKeys != nil {
6342		for i := range v.TagKeys {
6343			encoder.AddQuery("keys").String(v.TagKeys[i])
6344		}
6345	}
6346
6347	return nil
6348}
6349
6350type awsRestjson1_serializeOpUpdateAccountCustomization struct {
6351}
6352
6353func (*awsRestjson1_serializeOpUpdateAccountCustomization) ID() string {
6354	return "OperationSerializer"
6355}
6356
6357func (m *awsRestjson1_serializeOpUpdateAccountCustomization) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6358	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6359) {
6360	request, ok := in.Request.(*smithyhttp.Request)
6361	if !ok {
6362		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6363	}
6364
6365	input, ok := in.Parameters.(*UpdateAccountCustomizationInput)
6366	_ = input
6367	if !ok {
6368		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6369	}
6370
6371	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/customizations")
6372	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6373	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6374	request.Method = "PUT"
6375	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6376	if err != nil {
6377		return out, metadata, &smithy.SerializationError{Err: err}
6378	}
6379
6380	if err := awsRestjson1_serializeOpHttpBindingsUpdateAccountCustomizationInput(input, restEncoder); err != nil {
6381		return out, metadata, &smithy.SerializationError{Err: err}
6382	}
6383
6384	restEncoder.SetHeader("Content-Type").String("application/json")
6385
6386	jsonEncoder := smithyjson.NewEncoder()
6387	if err := awsRestjson1_serializeOpDocumentUpdateAccountCustomizationInput(input, jsonEncoder.Value); err != nil {
6388		return out, metadata, &smithy.SerializationError{Err: err}
6389	}
6390
6391	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6392		return out, metadata, &smithy.SerializationError{Err: err}
6393	}
6394
6395	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6396		return out, metadata, &smithy.SerializationError{Err: err}
6397	}
6398	in.Request = request
6399
6400	return next.HandleSerialize(ctx, in)
6401}
6402func awsRestjson1_serializeOpHttpBindingsUpdateAccountCustomizationInput(v *UpdateAccountCustomizationInput, encoder *httpbinding.Encoder) error {
6403	if v == nil {
6404		return fmt.Errorf("unsupported serialization of nil %T", v)
6405	}
6406
6407	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
6408		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
6409	}
6410	if v.AwsAccountId != nil {
6411		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
6412			return err
6413		}
6414	}
6415
6416	if v.Namespace != nil {
6417		encoder.SetQuery("namespace").String(*v.Namespace)
6418	}
6419
6420	return nil
6421}
6422
6423func awsRestjson1_serializeOpDocumentUpdateAccountCustomizationInput(v *UpdateAccountCustomizationInput, value smithyjson.Value) error {
6424	object := value.Object()
6425	defer object.Close()
6426
6427	if v.AccountCustomization != nil {
6428		ok := object.Key("AccountCustomization")
6429		if err := awsRestjson1_serializeDocumentAccountCustomization(v.AccountCustomization, ok); err != nil {
6430			return err
6431		}
6432	}
6433
6434	return nil
6435}
6436
6437type awsRestjson1_serializeOpUpdateAccountSettings struct {
6438}
6439
6440func (*awsRestjson1_serializeOpUpdateAccountSettings) ID() string {
6441	return "OperationSerializer"
6442}
6443
6444func (m *awsRestjson1_serializeOpUpdateAccountSettings) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6445	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6446) {
6447	request, ok := in.Request.(*smithyhttp.Request)
6448	if !ok {
6449		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6450	}
6451
6452	input, ok := in.Parameters.(*UpdateAccountSettingsInput)
6453	_ = input
6454	if !ok {
6455		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6456	}
6457
6458	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/settings")
6459	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6460	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6461	request.Method = "PUT"
6462	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6463	if err != nil {
6464		return out, metadata, &smithy.SerializationError{Err: err}
6465	}
6466
6467	if err := awsRestjson1_serializeOpHttpBindingsUpdateAccountSettingsInput(input, restEncoder); err != nil {
6468		return out, metadata, &smithy.SerializationError{Err: err}
6469	}
6470
6471	restEncoder.SetHeader("Content-Type").String("application/json")
6472
6473	jsonEncoder := smithyjson.NewEncoder()
6474	if err := awsRestjson1_serializeOpDocumentUpdateAccountSettingsInput(input, jsonEncoder.Value); err != nil {
6475		return out, metadata, &smithy.SerializationError{Err: err}
6476	}
6477
6478	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6479		return out, metadata, &smithy.SerializationError{Err: err}
6480	}
6481
6482	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6483		return out, metadata, &smithy.SerializationError{Err: err}
6484	}
6485	in.Request = request
6486
6487	return next.HandleSerialize(ctx, in)
6488}
6489func awsRestjson1_serializeOpHttpBindingsUpdateAccountSettingsInput(v *UpdateAccountSettingsInput, encoder *httpbinding.Encoder) error {
6490	if v == nil {
6491		return fmt.Errorf("unsupported serialization of nil %T", v)
6492	}
6493
6494	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
6495		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
6496	}
6497	if v.AwsAccountId != nil {
6498		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
6499			return err
6500		}
6501	}
6502
6503	return nil
6504}
6505
6506func awsRestjson1_serializeOpDocumentUpdateAccountSettingsInput(v *UpdateAccountSettingsInput, value smithyjson.Value) error {
6507	object := value.Object()
6508	defer object.Close()
6509
6510	if v.DefaultNamespace != nil {
6511		ok := object.Key("DefaultNamespace")
6512		ok.String(*v.DefaultNamespace)
6513	}
6514
6515	if v.NotificationEmail != nil {
6516		ok := object.Key("NotificationEmail")
6517		ok.String(*v.NotificationEmail)
6518	}
6519
6520	return nil
6521}
6522
6523type awsRestjson1_serializeOpUpdateAnalysis struct {
6524}
6525
6526func (*awsRestjson1_serializeOpUpdateAnalysis) ID() string {
6527	return "OperationSerializer"
6528}
6529
6530func (m *awsRestjson1_serializeOpUpdateAnalysis) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6531	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6532) {
6533	request, ok := in.Request.(*smithyhttp.Request)
6534	if !ok {
6535		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6536	}
6537
6538	input, ok := in.Parameters.(*UpdateAnalysisInput)
6539	_ = input
6540	if !ok {
6541		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6542	}
6543
6544	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}")
6545	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6546	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6547	request.Method = "PUT"
6548	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6549	if err != nil {
6550		return out, metadata, &smithy.SerializationError{Err: err}
6551	}
6552
6553	if err := awsRestjson1_serializeOpHttpBindingsUpdateAnalysisInput(input, restEncoder); err != nil {
6554		return out, metadata, &smithy.SerializationError{Err: err}
6555	}
6556
6557	restEncoder.SetHeader("Content-Type").String("application/json")
6558
6559	jsonEncoder := smithyjson.NewEncoder()
6560	if err := awsRestjson1_serializeOpDocumentUpdateAnalysisInput(input, jsonEncoder.Value); err != nil {
6561		return out, metadata, &smithy.SerializationError{Err: err}
6562	}
6563
6564	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6565		return out, metadata, &smithy.SerializationError{Err: err}
6566	}
6567
6568	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6569		return out, metadata, &smithy.SerializationError{Err: err}
6570	}
6571	in.Request = request
6572
6573	return next.HandleSerialize(ctx, in)
6574}
6575func awsRestjson1_serializeOpHttpBindingsUpdateAnalysisInput(v *UpdateAnalysisInput, encoder *httpbinding.Encoder) error {
6576	if v == nil {
6577		return fmt.Errorf("unsupported serialization of nil %T", v)
6578	}
6579
6580	if v.AnalysisId == nil || len(*v.AnalysisId) == 0 {
6581		return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")}
6582	}
6583	if v.AnalysisId != nil {
6584		if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil {
6585			return err
6586		}
6587	}
6588
6589	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
6590		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
6591	}
6592	if v.AwsAccountId != nil {
6593		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
6594			return err
6595		}
6596	}
6597
6598	return nil
6599}
6600
6601func awsRestjson1_serializeOpDocumentUpdateAnalysisInput(v *UpdateAnalysisInput, value smithyjson.Value) error {
6602	object := value.Object()
6603	defer object.Close()
6604
6605	if v.Name != nil {
6606		ok := object.Key("Name")
6607		ok.String(*v.Name)
6608	}
6609
6610	if v.Parameters != nil {
6611		ok := object.Key("Parameters")
6612		if err := awsRestjson1_serializeDocumentParameters(v.Parameters, ok); err != nil {
6613			return err
6614		}
6615	}
6616
6617	if v.SourceEntity != nil {
6618		ok := object.Key("SourceEntity")
6619		if err := awsRestjson1_serializeDocumentAnalysisSourceEntity(v.SourceEntity, ok); err != nil {
6620			return err
6621		}
6622	}
6623
6624	if v.ThemeArn != nil {
6625		ok := object.Key("ThemeArn")
6626		ok.String(*v.ThemeArn)
6627	}
6628
6629	return nil
6630}
6631
6632type awsRestjson1_serializeOpUpdateAnalysisPermissions struct {
6633}
6634
6635func (*awsRestjson1_serializeOpUpdateAnalysisPermissions) ID() string {
6636	return "OperationSerializer"
6637}
6638
6639func (m *awsRestjson1_serializeOpUpdateAnalysisPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6640	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6641) {
6642	request, ok := in.Request.(*smithyhttp.Request)
6643	if !ok {
6644		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6645	}
6646
6647	input, ok := in.Parameters.(*UpdateAnalysisPermissionsInput)
6648	_ = input
6649	if !ok {
6650		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6651	}
6652
6653	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/analyses/{AnalysisId}/permissions")
6654	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6655	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6656	request.Method = "PUT"
6657	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6658	if err != nil {
6659		return out, metadata, &smithy.SerializationError{Err: err}
6660	}
6661
6662	if err := awsRestjson1_serializeOpHttpBindingsUpdateAnalysisPermissionsInput(input, restEncoder); err != nil {
6663		return out, metadata, &smithy.SerializationError{Err: err}
6664	}
6665
6666	restEncoder.SetHeader("Content-Type").String("application/json")
6667
6668	jsonEncoder := smithyjson.NewEncoder()
6669	if err := awsRestjson1_serializeOpDocumentUpdateAnalysisPermissionsInput(input, jsonEncoder.Value); err != nil {
6670		return out, metadata, &smithy.SerializationError{Err: err}
6671	}
6672
6673	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6674		return out, metadata, &smithy.SerializationError{Err: err}
6675	}
6676
6677	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6678		return out, metadata, &smithy.SerializationError{Err: err}
6679	}
6680	in.Request = request
6681
6682	return next.HandleSerialize(ctx, in)
6683}
6684func awsRestjson1_serializeOpHttpBindingsUpdateAnalysisPermissionsInput(v *UpdateAnalysisPermissionsInput, encoder *httpbinding.Encoder) error {
6685	if v == nil {
6686		return fmt.Errorf("unsupported serialization of nil %T", v)
6687	}
6688
6689	if v.AnalysisId == nil || len(*v.AnalysisId) == 0 {
6690		return &smithy.SerializationError{Err: fmt.Errorf("input member AnalysisId must not be empty")}
6691	}
6692	if v.AnalysisId != nil {
6693		if err := encoder.SetURI("AnalysisId").String(*v.AnalysisId); err != nil {
6694			return err
6695		}
6696	}
6697
6698	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
6699		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
6700	}
6701	if v.AwsAccountId != nil {
6702		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
6703			return err
6704		}
6705	}
6706
6707	return nil
6708}
6709
6710func awsRestjson1_serializeOpDocumentUpdateAnalysisPermissionsInput(v *UpdateAnalysisPermissionsInput, value smithyjson.Value) error {
6711	object := value.Object()
6712	defer object.Close()
6713
6714	if v.GrantPermissions != nil {
6715		ok := object.Key("GrantPermissions")
6716		if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.GrantPermissions, ok); err != nil {
6717			return err
6718		}
6719	}
6720
6721	if v.RevokePermissions != nil {
6722		ok := object.Key("RevokePermissions")
6723		if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.RevokePermissions, ok); err != nil {
6724			return err
6725		}
6726	}
6727
6728	return nil
6729}
6730
6731type awsRestjson1_serializeOpUpdateDashboard struct {
6732}
6733
6734func (*awsRestjson1_serializeOpUpdateDashboard) ID() string {
6735	return "OperationSerializer"
6736}
6737
6738func (m *awsRestjson1_serializeOpUpdateDashboard) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6739	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6740) {
6741	request, ok := in.Request.(*smithyhttp.Request)
6742	if !ok {
6743		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6744	}
6745
6746	input, ok := in.Parameters.(*UpdateDashboardInput)
6747	_ = input
6748	if !ok {
6749		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6750	}
6751
6752	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}")
6753	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6754	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6755	request.Method = "PUT"
6756	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6757	if err != nil {
6758		return out, metadata, &smithy.SerializationError{Err: err}
6759	}
6760
6761	if err := awsRestjson1_serializeOpHttpBindingsUpdateDashboardInput(input, restEncoder); err != nil {
6762		return out, metadata, &smithy.SerializationError{Err: err}
6763	}
6764
6765	restEncoder.SetHeader("Content-Type").String("application/json")
6766
6767	jsonEncoder := smithyjson.NewEncoder()
6768	if err := awsRestjson1_serializeOpDocumentUpdateDashboardInput(input, jsonEncoder.Value); err != nil {
6769		return out, metadata, &smithy.SerializationError{Err: err}
6770	}
6771
6772	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6773		return out, metadata, &smithy.SerializationError{Err: err}
6774	}
6775
6776	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6777		return out, metadata, &smithy.SerializationError{Err: err}
6778	}
6779	in.Request = request
6780
6781	return next.HandleSerialize(ctx, in)
6782}
6783func awsRestjson1_serializeOpHttpBindingsUpdateDashboardInput(v *UpdateDashboardInput, encoder *httpbinding.Encoder) error {
6784	if v == nil {
6785		return fmt.Errorf("unsupported serialization of nil %T", v)
6786	}
6787
6788	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
6789		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
6790	}
6791	if v.AwsAccountId != nil {
6792		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
6793			return err
6794		}
6795	}
6796
6797	if v.DashboardId == nil || len(*v.DashboardId) == 0 {
6798		return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")}
6799	}
6800	if v.DashboardId != nil {
6801		if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil {
6802			return err
6803		}
6804	}
6805
6806	return nil
6807}
6808
6809func awsRestjson1_serializeOpDocumentUpdateDashboardInput(v *UpdateDashboardInput, value smithyjson.Value) error {
6810	object := value.Object()
6811	defer object.Close()
6812
6813	if v.DashboardPublishOptions != nil {
6814		ok := object.Key("DashboardPublishOptions")
6815		if err := awsRestjson1_serializeDocumentDashboardPublishOptions(v.DashboardPublishOptions, ok); err != nil {
6816			return err
6817		}
6818	}
6819
6820	if v.Name != nil {
6821		ok := object.Key("Name")
6822		ok.String(*v.Name)
6823	}
6824
6825	if v.Parameters != nil {
6826		ok := object.Key("Parameters")
6827		if err := awsRestjson1_serializeDocumentParameters(v.Parameters, ok); err != nil {
6828			return err
6829		}
6830	}
6831
6832	if v.SourceEntity != nil {
6833		ok := object.Key("SourceEntity")
6834		if err := awsRestjson1_serializeDocumentDashboardSourceEntity(v.SourceEntity, ok); err != nil {
6835			return err
6836		}
6837	}
6838
6839	if v.ThemeArn != nil {
6840		ok := object.Key("ThemeArn")
6841		ok.String(*v.ThemeArn)
6842	}
6843
6844	if v.VersionDescription != nil {
6845		ok := object.Key("VersionDescription")
6846		ok.String(*v.VersionDescription)
6847	}
6848
6849	return nil
6850}
6851
6852type awsRestjson1_serializeOpUpdateDashboardPermissions struct {
6853}
6854
6855func (*awsRestjson1_serializeOpUpdateDashboardPermissions) ID() string {
6856	return "OperationSerializer"
6857}
6858
6859func (m *awsRestjson1_serializeOpUpdateDashboardPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6860	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6861) {
6862	request, ok := in.Request.(*smithyhttp.Request)
6863	if !ok {
6864		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6865	}
6866
6867	input, ok := in.Parameters.(*UpdateDashboardPermissionsInput)
6868	_ = input
6869	if !ok {
6870		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6871	}
6872
6873	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}/permissions")
6874	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6875	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6876	request.Method = "PUT"
6877	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6878	if err != nil {
6879		return out, metadata, &smithy.SerializationError{Err: err}
6880	}
6881
6882	if err := awsRestjson1_serializeOpHttpBindingsUpdateDashboardPermissionsInput(input, restEncoder); err != nil {
6883		return out, metadata, &smithy.SerializationError{Err: err}
6884	}
6885
6886	restEncoder.SetHeader("Content-Type").String("application/json")
6887
6888	jsonEncoder := smithyjson.NewEncoder()
6889	if err := awsRestjson1_serializeOpDocumentUpdateDashboardPermissionsInput(input, jsonEncoder.Value); err != nil {
6890		return out, metadata, &smithy.SerializationError{Err: err}
6891	}
6892
6893	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
6894		return out, metadata, &smithy.SerializationError{Err: err}
6895	}
6896
6897	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6898		return out, metadata, &smithy.SerializationError{Err: err}
6899	}
6900	in.Request = request
6901
6902	return next.HandleSerialize(ctx, in)
6903}
6904func awsRestjson1_serializeOpHttpBindingsUpdateDashboardPermissionsInput(v *UpdateDashboardPermissionsInput, encoder *httpbinding.Encoder) error {
6905	if v == nil {
6906		return fmt.Errorf("unsupported serialization of nil %T", v)
6907	}
6908
6909	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
6910		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
6911	}
6912	if v.AwsAccountId != nil {
6913		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
6914			return err
6915		}
6916	}
6917
6918	if v.DashboardId == nil || len(*v.DashboardId) == 0 {
6919		return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")}
6920	}
6921	if v.DashboardId != nil {
6922		if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil {
6923			return err
6924		}
6925	}
6926
6927	return nil
6928}
6929
6930func awsRestjson1_serializeOpDocumentUpdateDashboardPermissionsInput(v *UpdateDashboardPermissionsInput, value smithyjson.Value) error {
6931	object := value.Object()
6932	defer object.Close()
6933
6934	if v.GrantPermissions != nil {
6935		ok := object.Key("GrantPermissions")
6936		if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.GrantPermissions, ok); err != nil {
6937			return err
6938		}
6939	}
6940
6941	if v.RevokePermissions != nil {
6942		ok := object.Key("RevokePermissions")
6943		if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.RevokePermissions, ok); err != nil {
6944			return err
6945		}
6946	}
6947
6948	return nil
6949}
6950
6951type awsRestjson1_serializeOpUpdateDashboardPublishedVersion struct {
6952}
6953
6954func (*awsRestjson1_serializeOpUpdateDashboardPublishedVersion) ID() string {
6955	return "OperationSerializer"
6956}
6957
6958func (m *awsRestjson1_serializeOpUpdateDashboardPublishedVersion) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
6959	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
6960) {
6961	request, ok := in.Request.(*smithyhttp.Request)
6962	if !ok {
6963		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
6964	}
6965
6966	input, ok := in.Parameters.(*UpdateDashboardPublishedVersionInput)
6967	_ = input
6968	if !ok {
6969		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
6970	}
6971
6972	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/dashboards/{DashboardId}/versions/{VersionNumber}")
6973	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
6974	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
6975	request.Method = "PUT"
6976	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
6977	if err != nil {
6978		return out, metadata, &smithy.SerializationError{Err: err}
6979	}
6980
6981	if err := awsRestjson1_serializeOpHttpBindingsUpdateDashboardPublishedVersionInput(input, restEncoder); err != nil {
6982		return out, metadata, &smithy.SerializationError{Err: err}
6983	}
6984
6985	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
6986		return out, metadata, &smithy.SerializationError{Err: err}
6987	}
6988	in.Request = request
6989
6990	return next.HandleSerialize(ctx, in)
6991}
6992func awsRestjson1_serializeOpHttpBindingsUpdateDashboardPublishedVersionInput(v *UpdateDashboardPublishedVersionInput, encoder *httpbinding.Encoder) error {
6993	if v == nil {
6994		return fmt.Errorf("unsupported serialization of nil %T", v)
6995	}
6996
6997	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
6998		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
6999	}
7000	if v.AwsAccountId != nil {
7001		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
7002			return err
7003		}
7004	}
7005
7006	if v.DashboardId == nil || len(*v.DashboardId) == 0 {
7007		return &smithy.SerializationError{Err: fmt.Errorf("input member DashboardId must not be empty")}
7008	}
7009	if v.DashboardId != nil {
7010		if err := encoder.SetURI("DashboardId").String(*v.DashboardId); err != nil {
7011			return err
7012		}
7013	}
7014
7015	if v.VersionNumber == nil {
7016		return &smithy.SerializationError{Err: fmt.Errorf("input member VersionNumber must not be empty")}
7017	}
7018	if v.VersionNumber != nil {
7019		if err := encoder.SetURI("VersionNumber").Long(*v.VersionNumber); err != nil {
7020			return err
7021		}
7022	}
7023
7024	return nil
7025}
7026
7027type awsRestjson1_serializeOpUpdateDataSet struct {
7028}
7029
7030func (*awsRestjson1_serializeOpUpdateDataSet) ID() string {
7031	return "OperationSerializer"
7032}
7033
7034func (m *awsRestjson1_serializeOpUpdateDataSet) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7035	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7036) {
7037	request, ok := in.Request.(*smithyhttp.Request)
7038	if !ok {
7039		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7040	}
7041
7042	input, ok := in.Parameters.(*UpdateDataSetInput)
7043	_ = input
7044	if !ok {
7045		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7046	}
7047
7048	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}")
7049	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7050	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7051	request.Method = "PUT"
7052	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7053	if err != nil {
7054		return out, metadata, &smithy.SerializationError{Err: err}
7055	}
7056
7057	if err := awsRestjson1_serializeOpHttpBindingsUpdateDataSetInput(input, restEncoder); err != nil {
7058		return out, metadata, &smithy.SerializationError{Err: err}
7059	}
7060
7061	restEncoder.SetHeader("Content-Type").String("application/json")
7062
7063	jsonEncoder := smithyjson.NewEncoder()
7064	if err := awsRestjson1_serializeOpDocumentUpdateDataSetInput(input, jsonEncoder.Value); err != nil {
7065		return out, metadata, &smithy.SerializationError{Err: err}
7066	}
7067
7068	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7069		return out, metadata, &smithy.SerializationError{Err: err}
7070	}
7071
7072	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7073		return out, metadata, &smithy.SerializationError{Err: err}
7074	}
7075	in.Request = request
7076
7077	return next.HandleSerialize(ctx, in)
7078}
7079func awsRestjson1_serializeOpHttpBindingsUpdateDataSetInput(v *UpdateDataSetInput, encoder *httpbinding.Encoder) error {
7080	if v == nil {
7081		return fmt.Errorf("unsupported serialization of nil %T", v)
7082	}
7083
7084	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
7085		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
7086	}
7087	if v.AwsAccountId != nil {
7088		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
7089			return err
7090		}
7091	}
7092
7093	if v.DataSetId == nil || len(*v.DataSetId) == 0 {
7094		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")}
7095	}
7096	if v.DataSetId != nil {
7097		if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil {
7098			return err
7099		}
7100	}
7101
7102	return nil
7103}
7104
7105func awsRestjson1_serializeOpDocumentUpdateDataSetInput(v *UpdateDataSetInput, value smithyjson.Value) error {
7106	object := value.Object()
7107	defer object.Close()
7108
7109	if v.ColumnGroups != nil {
7110		ok := object.Key("ColumnGroups")
7111		if err := awsRestjson1_serializeDocumentColumnGroupList(v.ColumnGroups, ok); err != nil {
7112			return err
7113		}
7114	}
7115
7116	if v.ColumnLevelPermissionRules != nil {
7117		ok := object.Key("ColumnLevelPermissionRules")
7118		if err := awsRestjson1_serializeDocumentColumnLevelPermissionRuleList(v.ColumnLevelPermissionRules, ok); err != nil {
7119			return err
7120		}
7121	}
7122
7123	if v.FieldFolders != nil {
7124		ok := object.Key("FieldFolders")
7125		if err := awsRestjson1_serializeDocumentFieldFolderMap(v.FieldFolders, ok); err != nil {
7126			return err
7127		}
7128	}
7129
7130	if len(v.ImportMode) > 0 {
7131		ok := object.Key("ImportMode")
7132		ok.String(string(v.ImportMode))
7133	}
7134
7135	if v.LogicalTableMap != nil {
7136		ok := object.Key("LogicalTableMap")
7137		if err := awsRestjson1_serializeDocumentLogicalTableMap(v.LogicalTableMap, ok); err != nil {
7138			return err
7139		}
7140	}
7141
7142	if v.Name != nil {
7143		ok := object.Key("Name")
7144		ok.String(*v.Name)
7145	}
7146
7147	if v.PhysicalTableMap != nil {
7148		ok := object.Key("PhysicalTableMap")
7149		if err := awsRestjson1_serializeDocumentPhysicalTableMap(v.PhysicalTableMap, ok); err != nil {
7150			return err
7151		}
7152	}
7153
7154	if v.RowLevelPermissionDataSet != nil {
7155		ok := object.Key("RowLevelPermissionDataSet")
7156		if err := awsRestjson1_serializeDocumentRowLevelPermissionDataSet(v.RowLevelPermissionDataSet, ok); err != nil {
7157			return err
7158		}
7159	}
7160
7161	return nil
7162}
7163
7164type awsRestjson1_serializeOpUpdateDataSetPermissions struct {
7165}
7166
7167func (*awsRestjson1_serializeOpUpdateDataSetPermissions) ID() string {
7168	return "OperationSerializer"
7169}
7170
7171func (m *awsRestjson1_serializeOpUpdateDataSetPermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7172	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7173) {
7174	request, ok := in.Request.(*smithyhttp.Request)
7175	if !ok {
7176		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7177	}
7178
7179	input, ok := in.Parameters.(*UpdateDataSetPermissionsInput)
7180	_ = input
7181	if !ok {
7182		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7183	}
7184
7185	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sets/{DataSetId}/permissions")
7186	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7187	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7188	request.Method = "POST"
7189	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7190	if err != nil {
7191		return out, metadata, &smithy.SerializationError{Err: err}
7192	}
7193
7194	if err := awsRestjson1_serializeOpHttpBindingsUpdateDataSetPermissionsInput(input, restEncoder); err != nil {
7195		return out, metadata, &smithy.SerializationError{Err: err}
7196	}
7197
7198	restEncoder.SetHeader("Content-Type").String("application/json")
7199
7200	jsonEncoder := smithyjson.NewEncoder()
7201	if err := awsRestjson1_serializeOpDocumentUpdateDataSetPermissionsInput(input, jsonEncoder.Value); err != nil {
7202		return out, metadata, &smithy.SerializationError{Err: err}
7203	}
7204
7205	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7206		return out, metadata, &smithy.SerializationError{Err: err}
7207	}
7208
7209	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7210		return out, metadata, &smithy.SerializationError{Err: err}
7211	}
7212	in.Request = request
7213
7214	return next.HandleSerialize(ctx, in)
7215}
7216func awsRestjson1_serializeOpHttpBindingsUpdateDataSetPermissionsInput(v *UpdateDataSetPermissionsInput, encoder *httpbinding.Encoder) error {
7217	if v == nil {
7218		return fmt.Errorf("unsupported serialization of nil %T", v)
7219	}
7220
7221	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
7222		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
7223	}
7224	if v.AwsAccountId != nil {
7225		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
7226			return err
7227		}
7228	}
7229
7230	if v.DataSetId == nil || len(*v.DataSetId) == 0 {
7231		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSetId must not be empty")}
7232	}
7233	if v.DataSetId != nil {
7234		if err := encoder.SetURI("DataSetId").String(*v.DataSetId); err != nil {
7235			return err
7236		}
7237	}
7238
7239	return nil
7240}
7241
7242func awsRestjson1_serializeOpDocumentUpdateDataSetPermissionsInput(v *UpdateDataSetPermissionsInput, value smithyjson.Value) error {
7243	object := value.Object()
7244	defer object.Close()
7245
7246	if v.GrantPermissions != nil {
7247		ok := object.Key("GrantPermissions")
7248		if err := awsRestjson1_serializeDocumentResourcePermissionList(v.GrantPermissions, ok); err != nil {
7249			return err
7250		}
7251	}
7252
7253	if v.RevokePermissions != nil {
7254		ok := object.Key("RevokePermissions")
7255		if err := awsRestjson1_serializeDocumentResourcePermissionList(v.RevokePermissions, ok); err != nil {
7256			return err
7257		}
7258	}
7259
7260	return nil
7261}
7262
7263type awsRestjson1_serializeOpUpdateDataSource struct {
7264}
7265
7266func (*awsRestjson1_serializeOpUpdateDataSource) ID() string {
7267	return "OperationSerializer"
7268}
7269
7270func (m *awsRestjson1_serializeOpUpdateDataSource) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7271	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7272) {
7273	request, ok := in.Request.(*smithyhttp.Request)
7274	if !ok {
7275		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7276	}
7277
7278	input, ok := in.Parameters.(*UpdateDataSourceInput)
7279	_ = input
7280	if !ok {
7281		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7282	}
7283
7284	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources/{DataSourceId}")
7285	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7286	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7287	request.Method = "PUT"
7288	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7289	if err != nil {
7290		return out, metadata, &smithy.SerializationError{Err: err}
7291	}
7292
7293	if err := awsRestjson1_serializeOpHttpBindingsUpdateDataSourceInput(input, restEncoder); err != nil {
7294		return out, metadata, &smithy.SerializationError{Err: err}
7295	}
7296
7297	restEncoder.SetHeader("Content-Type").String("application/json")
7298
7299	jsonEncoder := smithyjson.NewEncoder()
7300	if err := awsRestjson1_serializeOpDocumentUpdateDataSourceInput(input, jsonEncoder.Value); err != nil {
7301		return out, metadata, &smithy.SerializationError{Err: err}
7302	}
7303
7304	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7305		return out, metadata, &smithy.SerializationError{Err: err}
7306	}
7307
7308	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7309		return out, metadata, &smithy.SerializationError{Err: err}
7310	}
7311	in.Request = request
7312
7313	return next.HandleSerialize(ctx, in)
7314}
7315func awsRestjson1_serializeOpHttpBindingsUpdateDataSourceInput(v *UpdateDataSourceInput, encoder *httpbinding.Encoder) error {
7316	if v == nil {
7317		return fmt.Errorf("unsupported serialization of nil %T", v)
7318	}
7319
7320	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
7321		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
7322	}
7323	if v.AwsAccountId != nil {
7324		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
7325			return err
7326		}
7327	}
7328
7329	if v.DataSourceId == nil || len(*v.DataSourceId) == 0 {
7330		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSourceId must not be empty")}
7331	}
7332	if v.DataSourceId != nil {
7333		if err := encoder.SetURI("DataSourceId").String(*v.DataSourceId); err != nil {
7334			return err
7335		}
7336	}
7337
7338	return nil
7339}
7340
7341func awsRestjson1_serializeOpDocumentUpdateDataSourceInput(v *UpdateDataSourceInput, value smithyjson.Value) error {
7342	object := value.Object()
7343	defer object.Close()
7344
7345	if v.Credentials != nil {
7346		ok := object.Key("Credentials")
7347		if err := awsRestjson1_serializeDocumentDataSourceCredentials(v.Credentials, ok); err != nil {
7348			return err
7349		}
7350	}
7351
7352	if v.DataSourceParameters != nil {
7353		ok := object.Key("DataSourceParameters")
7354		if err := awsRestjson1_serializeDocumentDataSourceParameters(v.DataSourceParameters, ok); err != nil {
7355			return err
7356		}
7357	}
7358
7359	if v.Name != nil {
7360		ok := object.Key("Name")
7361		ok.String(*v.Name)
7362	}
7363
7364	if v.SslProperties != nil {
7365		ok := object.Key("SslProperties")
7366		if err := awsRestjson1_serializeDocumentSslProperties(v.SslProperties, ok); err != nil {
7367			return err
7368		}
7369	}
7370
7371	if v.VpcConnectionProperties != nil {
7372		ok := object.Key("VpcConnectionProperties")
7373		if err := awsRestjson1_serializeDocumentVpcConnectionProperties(v.VpcConnectionProperties, ok); err != nil {
7374			return err
7375		}
7376	}
7377
7378	return nil
7379}
7380
7381type awsRestjson1_serializeOpUpdateDataSourcePermissions struct {
7382}
7383
7384func (*awsRestjson1_serializeOpUpdateDataSourcePermissions) ID() string {
7385	return "OperationSerializer"
7386}
7387
7388func (m *awsRestjson1_serializeOpUpdateDataSourcePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7389	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7390) {
7391	request, ok := in.Request.(*smithyhttp.Request)
7392	if !ok {
7393		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7394	}
7395
7396	input, ok := in.Parameters.(*UpdateDataSourcePermissionsInput)
7397	_ = input
7398	if !ok {
7399		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7400	}
7401
7402	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/data-sources/{DataSourceId}/permissions")
7403	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7404	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7405	request.Method = "POST"
7406	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7407	if err != nil {
7408		return out, metadata, &smithy.SerializationError{Err: err}
7409	}
7410
7411	if err := awsRestjson1_serializeOpHttpBindingsUpdateDataSourcePermissionsInput(input, restEncoder); err != nil {
7412		return out, metadata, &smithy.SerializationError{Err: err}
7413	}
7414
7415	restEncoder.SetHeader("Content-Type").String("application/json")
7416
7417	jsonEncoder := smithyjson.NewEncoder()
7418	if err := awsRestjson1_serializeOpDocumentUpdateDataSourcePermissionsInput(input, jsonEncoder.Value); err != nil {
7419		return out, metadata, &smithy.SerializationError{Err: err}
7420	}
7421
7422	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7423		return out, metadata, &smithy.SerializationError{Err: err}
7424	}
7425
7426	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7427		return out, metadata, &smithy.SerializationError{Err: err}
7428	}
7429	in.Request = request
7430
7431	return next.HandleSerialize(ctx, in)
7432}
7433func awsRestjson1_serializeOpHttpBindingsUpdateDataSourcePermissionsInput(v *UpdateDataSourcePermissionsInput, encoder *httpbinding.Encoder) error {
7434	if v == nil {
7435		return fmt.Errorf("unsupported serialization of nil %T", v)
7436	}
7437
7438	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
7439		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
7440	}
7441	if v.AwsAccountId != nil {
7442		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
7443			return err
7444		}
7445	}
7446
7447	if v.DataSourceId == nil || len(*v.DataSourceId) == 0 {
7448		return &smithy.SerializationError{Err: fmt.Errorf("input member DataSourceId must not be empty")}
7449	}
7450	if v.DataSourceId != nil {
7451		if err := encoder.SetURI("DataSourceId").String(*v.DataSourceId); err != nil {
7452			return err
7453		}
7454	}
7455
7456	return nil
7457}
7458
7459func awsRestjson1_serializeOpDocumentUpdateDataSourcePermissionsInput(v *UpdateDataSourcePermissionsInput, value smithyjson.Value) error {
7460	object := value.Object()
7461	defer object.Close()
7462
7463	if v.GrantPermissions != nil {
7464		ok := object.Key("GrantPermissions")
7465		if err := awsRestjson1_serializeDocumentResourcePermissionList(v.GrantPermissions, ok); err != nil {
7466			return err
7467		}
7468	}
7469
7470	if v.RevokePermissions != nil {
7471		ok := object.Key("RevokePermissions")
7472		if err := awsRestjson1_serializeDocumentResourcePermissionList(v.RevokePermissions, ok); err != nil {
7473			return err
7474		}
7475	}
7476
7477	return nil
7478}
7479
7480type awsRestjson1_serializeOpUpdateGroup struct {
7481}
7482
7483func (*awsRestjson1_serializeOpUpdateGroup) ID() string {
7484	return "OperationSerializer"
7485}
7486
7487func (m *awsRestjson1_serializeOpUpdateGroup) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7488	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7489) {
7490	request, ok := in.Request.(*smithyhttp.Request)
7491	if !ok {
7492		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7493	}
7494
7495	input, ok := in.Parameters.(*UpdateGroupInput)
7496	_ = input
7497	if !ok {
7498		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7499	}
7500
7501	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/groups/{GroupName}")
7502	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7503	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7504	request.Method = "PUT"
7505	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7506	if err != nil {
7507		return out, metadata, &smithy.SerializationError{Err: err}
7508	}
7509
7510	if err := awsRestjson1_serializeOpHttpBindingsUpdateGroupInput(input, restEncoder); err != nil {
7511		return out, metadata, &smithy.SerializationError{Err: err}
7512	}
7513
7514	restEncoder.SetHeader("Content-Type").String("application/json")
7515
7516	jsonEncoder := smithyjson.NewEncoder()
7517	if err := awsRestjson1_serializeOpDocumentUpdateGroupInput(input, jsonEncoder.Value); err != nil {
7518		return out, metadata, &smithy.SerializationError{Err: err}
7519	}
7520
7521	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7522		return out, metadata, &smithy.SerializationError{Err: err}
7523	}
7524
7525	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7526		return out, metadata, &smithy.SerializationError{Err: err}
7527	}
7528	in.Request = request
7529
7530	return next.HandleSerialize(ctx, in)
7531}
7532func awsRestjson1_serializeOpHttpBindingsUpdateGroupInput(v *UpdateGroupInput, encoder *httpbinding.Encoder) error {
7533	if v == nil {
7534		return fmt.Errorf("unsupported serialization of nil %T", v)
7535	}
7536
7537	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
7538		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
7539	}
7540	if v.AwsAccountId != nil {
7541		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
7542			return err
7543		}
7544	}
7545
7546	if v.GroupName == nil || len(*v.GroupName) == 0 {
7547		return &smithy.SerializationError{Err: fmt.Errorf("input member GroupName must not be empty")}
7548	}
7549	if v.GroupName != nil {
7550		if err := encoder.SetURI("GroupName").String(*v.GroupName); err != nil {
7551			return err
7552		}
7553	}
7554
7555	if v.Namespace == nil || len(*v.Namespace) == 0 {
7556		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
7557	}
7558	if v.Namespace != nil {
7559		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
7560			return err
7561		}
7562	}
7563
7564	return nil
7565}
7566
7567func awsRestjson1_serializeOpDocumentUpdateGroupInput(v *UpdateGroupInput, value smithyjson.Value) error {
7568	object := value.Object()
7569	defer object.Close()
7570
7571	if v.Description != nil {
7572		ok := object.Key("Description")
7573		ok.String(*v.Description)
7574	}
7575
7576	return nil
7577}
7578
7579type awsRestjson1_serializeOpUpdateIAMPolicyAssignment struct {
7580}
7581
7582func (*awsRestjson1_serializeOpUpdateIAMPolicyAssignment) ID() string {
7583	return "OperationSerializer"
7584}
7585
7586func (m *awsRestjson1_serializeOpUpdateIAMPolicyAssignment) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7587	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7588) {
7589	request, ok := in.Request.(*smithyhttp.Request)
7590	if !ok {
7591		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7592	}
7593
7594	input, ok := in.Parameters.(*UpdateIAMPolicyAssignmentInput)
7595	_ = input
7596	if !ok {
7597		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7598	}
7599
7600	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/iam-policy-assignments/{AssignmentName}")
7601	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7602	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7603	request.Method = "PUT"
7604	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7605	if err != nil {
7606		return out, metadata, &smithy.SerializationError{Err: err}
7607	}
7608
7609	if err := awsRestjson1_serializeOpHttpBindingsUpdateIAMPolicyAssignmentInput(input, restEncoder); err != nil {
7610		return out, metadata, &smithy.SerializationError{Err: err}
7611	}
7612
7613	restEncoder.SetHeader("Content-Type").String("application/json")
7614
7615	jsonEncoder := smithyjson.NewEncoder()
7616	if err := awsRestjson1_serializeOpDocumentUpdateIAMPolicyAssignmentInput(input, jsonEncoder.Value); err != nil {
7617		return out, metadata, &smithy.SerializationError{Err: err}
7618	}
7619
7620	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7621		return out, metadata, &smithy.SerializationError{Err: err}
7622	}
7623
7624	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7625		return out, metadata, &smithy.SerializationError{Err: err}
7626	}
7627	in.Request = request
7628
7629	return next.HandleSerialize(ctx, in)
7630}
7631func awsRestjson1_serializeOpHttpBindingsUpdateIAMPolicyAssignmentInput(v *UpdateIAMPolicyAssignmentInput, encoder *httpbinding.Encoder) error {
7632	if v == nil {
7633		return fmt.Errorf("unsupported serialization of nil %T", v)
7634	}
7635
7636	if v.AssignmentName == nil || len(*v.AssignmentName) == 0 {
7637		return &smithy.SerializationError{Err: fmt.Errorf("input member AssignmentName must not be empty")}
7638	}
7639	if v.AssignmentName != nil {
7640		if err := encoder.SetURI("AssignmentName").String(*v.AssignmentName); err != nil {
7641			return err
7642		}
7643	}
7644
7645	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
7646		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
7647	}
7648	if v.AwsAccountId != nil {
7649		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
7650			return err
7651		}
7652	}
7653
7654	if v.Namespace == nil || len(*v.Namespace) == 0 {
7655		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
7656	}
7657	if v.Namespace != nil {
7658		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
7659			return err
7660		}
7661	}
7662
7663	return nil
7664}
7665
7666func awsRestjson1_serializeOpDocumentUpdateIAMPolicyAssignmentInput(v *UpdateIAMPolicyAssignmentInput, value smithyjson.Value) error {
7667	object := value.Object()
7668	defer object.Close()
7669
7670	if len(v.AssignmentStatus) > 0 {
7671		ok := object.Key("AssignmentStatus")
7672		ok.String(string(v.AssignmentStatus))
7673	}
7674
7675	if v.Identities != nil {
7676		ok := object.Key("Identities")
7677		if err := awsRestjson1_serializeDocumentIdentityMap(v.Identities, ok); err != nil {
7678			return err
7679		}
7680	}
7681
7682	if v.PolicyArn != nil {
7683		ok := object.Key("PolicyArn")
7684		ok.String(*v.PolicyArn)
7685	}
7686
7687	return nil
7688}
7689
7690type awsRestjson1_serializeOpUpdateTemplate struct {
7691}
7692
7693func (*awsRestjson1_serializeOpUpdateTemplate) ID() string {
7694	return "OperationSerializer"
7695}
7696
7697func (m *awsRestjson1_serializeOpUpdateTemplate) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7698	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7699) {
7700	request, ok := in.Request.(*smithyhttp.Request)
7701	if !ok {
7702		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7703	}
7704
7705	input, ok := in.Parameters.(*UpdateTemplateInput)
7706	_ = input
7707	if !ok {
7708		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7709	}
7710
7711	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}")
7712	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7713	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7714	request.Method = "PUT"
7715	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7716	if err != nil {
7717		return out, metadata, &smithy.SerializationError{Err: err}
7718	}
7719
7720	if err := awsRestjson1_serializeOpHttpBindingsUpdateTemplateInput(input, restEncoder); err != nil {
7721		return out, metadata, &smithy.SerializationError{Err: err}
7722	}
7723
7724	restEncoder.SetHeader("Content-Type").String("application/json")
7725
7726	jsonEncoder := smithyjson.NewEncoder()
7727	if err := awsRestjson1_serializeOpDocumentUpdateTemplateInput(input, jsonEncoder.Value); err != nil {
7728		return out, metadata, &smithy.SerializationError{Err: err}
7729	}
7730
7731	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7732		return out, metadata, &smithy.SerializationError{Err: err}
7733	}
7734
7735	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7736		return out, metadata, &smithy.SerializationError{Err: err}
7737	}
7738	in.Request = request
7739
7740	return next.HandleSerialize(ctx, in)
7741}
7742func awsRestjson1_serializeOpHttpBindingsUpdateTemplateInput(v *UpdateTemplateInput, encoder *httpbinding.Encoder) error {
7743	if v == nil {
7744		return fmt.Errorf("unsupported serialization of nil %T", v)
7745	}
7746
7747	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
7748		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
7749	}
7750	if v.AwsAccountId != nil {
7751		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
7752			return err
7753		}
7754	}
7755
7756	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
7757		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
7758	}
7759	if v.TemplateId != nil {
7760		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
7761			return err
7762		}
7763	}
7764
7765	return nil
7766}
7767
7768func awsRestjson1_serializeOpDocumentUpdateTemplateInput(v *UpdateTemplateInput, value smithyjson.Value) error {
7769	object := value.Object()
7770	defer object.Close()
7771
7772	if v.Name != nil {
7773		ok := object.Key("Name")
7774		ok.String(*v.Name)
7775	}
7776
7777	if v.SourceEntity != nil {
7778		ok := object.Key("SourceEntity")
7779		if err := awsRestjson1_serializeDocumentTemplateSourceEntity(v.SourceEntity, ok); err != nil {
7780			return err
7781		}
7782	}
7783
7784	if v.VersionDescription != nil {
7785		ok := object.Key("VersionDescription")
7786		ok.String(*v.VersionDescription)
7787	}
7788
7789	return nil
7790}
7791
7792type awsRestjson1_serializeOpUpdateTemplateAlias struct {
7793}
7794
7795func (*awsRestjson1_serializeOpUpdateTemplateAlias) ID() string {
7796	return "OperationSerializer"
7797}
7798
7799func (m *awsRestjson1_serializeOpUpdateTemplateAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7800	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7801) {
7802	request, ok := in.Request.(*smithyhttp.Request)
7803	if !ok {
7804		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7805	}
7806
7807	input, ok := in.Parameters.(*UpdateTemplateAliasInput)
7808	_ = input
7809	if !ok {
7810		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7811	}
7812
7813	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/aliases/{AliasName}")
7814	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7815	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7816	request.Method = "PUT"
7817	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7818	if err != nil {
7819		return out, metadata, &smithy.SerializationError{Err: err}
7820	}
7821
7822	if err := awsRestjson1_serializeOpHttpBindingsUpdateTemplateAliasInput(input, restEncoder); err != nil {
7823		return out, metadata, &smithy.SerializationError{Err: err}
7824	}
7825
7826	restEncoder.SetHeader("Content-Type").String("application/json")
7827
7828	jsonEncoder := smithyjson.NewEncoder()
7829	if err := awsRestjson1_serializeOpDocumentUpdateTemplateAliasInput(input, jsonEncoder.Value); err != nil {
7830		return out, metadata, &smithy.SerializationError{Err: err}
7831	}
7832
7833	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7834		return out, metadata, &smithy.SerializationError{Err: err}
7835	}
7836
7837	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7838		return out, metadata, &smithy.SerializationError{Err: err}
7839	}
7840	in.Request = request
7841
7842	return next.HandleSerialize(ctx, in)
7843}
7844func awsRestjson1_serializeOpHttpBindingsUpdateTemplateAliasInput(v *UpdateTemplateAliasInput, encoder *httpbinding.Encoder) error {
7845	if v == nil {
7846		return fmt.Errorf("unsupported serialization of nil %T", v)
7847	}
7848
7849	if v.AliasName == nil || len(*v.AliasName) == 0 {
7850		return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")}
7851	}
7852	if v.AliasName != nil {
7853		if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil {
7854			return err
7855		}
7856	}
7857
7858	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
7859		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
7860	}
7861	if v.AwsAccountId != nil {
7862		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
7863			return err
7864		}
7865	}
7866
7867	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
7868		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
7869	}
7870	if v.TemplateId != nil {
7871		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
7872			return err
7873		}
7874	}
7875
7876	return nil
7877}
7878
7879func awsRestjson1_serializeOpDocumentUpdateTemplateAliasInput(v *UpdateTemplateAliasInput, value smithyjson.Value) error {
7880	object := value.Object()
7881	defer object.Close()
7882
7883	if v.TemplateVersionNumber != nil {
7884		ok := object.Key("TemplateVersionNumber")
7885		ok.Long(*v.TemplateVersionNumber)
7886	}
7887
7888	return nil
7889}
7890
7891type awsRestjson1_serializeOpUpdateTemplatePermissions struct {
7892}
7893
7894func (*awsRestjson1_serializeOpUpdateTemplatePermissions) ID() string {
7895	return "OperationSerializer"
7896}
7897
7898func (m *awsRestjson1_serializeOpUpdateTemplatePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7899	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7900) {
7901	request, ok := in.Request.(*smithyhttp.Request)
7902	if !ok {
7903		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
7904	}
7905
7906	input, ok := in.Parameters.(*UpdateTemplatePermissionsInput)
7907	_ = input
7908	if !ok {
7909		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
7910	}
7911
7912	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/templates/{TemplateId}/permissions")
7913	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
7914	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
7915	request.Method = "PUT"
7916	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
7917	if err != nil {
7918		return out, metadata, &smithy.SerializationError{Err: err}
7919	}
7920
7921	if err := awsRestjson1_serializeOpHttpBindingsUpdateTemplatePermissionsInput(input, restEncoder); err != nil {
7922		return out, metadata, &smithy.SerializationError{Err: err}
7923	}
7924
7925	restEncoder.SetHeader("Content-Type").String("application/json")
7926
7927	jsonEncoder := smithyjson.NewEncoder()
7928	if err := awsRestjson1_serializeOpDocumentUpdateTemplatePermissionsInput(input, jsonEncoder.Value); err != nil {
7929		return out, metadata, &smithy.SerializationError{Err: err}
7930	}
7931
7932	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
7933		return out, metadata, &smithy.SerializationError{Err: err}
7934	}
7935
7936	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
7937		return out, metadata, &smithy.SerializationError{Err: err}
7938	}
7939	in.Request = request
7940
7941	return next.HandleSerialize(ctx, in)
7942}
7943func awsRestjson1_serializeOpHttpBindingsUpdateTemplatePermissionsInput(v *UpdateTemplatePermissionsInput, encoder *httpbinding.Encoder) error {
7944	if v == nil {
7945		return fmt.Errorf("unsupported serialization of nil %T", v)
7946	}
7947
7948	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
7949		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
7950	}
7951	if v.AwsAccountId != nil {
7952		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
7953			return err
7954		}
7955	}
7956
7957	if v.TemplateId == nil || len(*v.TemplateId) == 0 {
7958		return &smithy.SerializationError{Err: fmt.Errorf("input member TemplateId must not be empty")}
7959	}
7960	if v.TemplateId != nil {
7961		if err := encoder.SetURI("TemplateId").String(*v.TemplateId); err != nil {
7962			return err
7963		}
7964	}
7965
7966	return nil
7967}
7968
7969func awsRestjson1_serializeOpDocumentUpdateTemplatePermissionsInput(v *UpdateTemplatePermissionsInput, value smithyjson.Value) error {
7970	object := value.Object()
7971	defer object.Close()
7972
7973	if v.GrantPermissions != nil {
7974		ok := object.Key("GrantPermissions")
7975		if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.GrantPermissions, ok); err != nil {
7976			return err
7977		}
7978	}
7979
7980	if v.RevokePermissions != nil {
7981		ok := object.Key("RevokePermissions")
7982		if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.RevokePermissions, ok); err != nil {
7983			return err
7984		}
7985	}
7986
7987	return nil
7988}
7989
7990type awsRestjson1_serializeOpUpdateTheme struct {
7991}
7992
7993func (*awsRestjson1_serializeOpUpdateTheme) ID() string {
7994	return "OperationSerializer"
7995}
7996
7997func (m *awsRestjson1_serializeOpUpdateTheme) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
7998	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
7999) {
8000	request, ok := in.Request.(*smithyhttp.Request)
8001	if !ok {
8002		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8003	}
8004
8005	input, ok := in.Parameters.(*UpdateThemeInput)
8006	_ = input
8007	if !ok {
8008		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8009	}
8010
8011	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}")
8012	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8013	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8014	request.Method = "PUT"
8015	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8016	if err != nil {
8017		return out, metadata, &smithy.SerializationError{Err: err}
8018	}
8019
8020	if err := awsRestjson1_serializeOpHttpBindingsUpdateThemeInput(input, restEncoder); err != nil {
8021		return out, metadata, &smithy.SerializationError{Err: err}
8022	}
8023
8024	restEncoder.SetHeader("Content-Type").String("application/json")
8025
8026	jsonEncoder := smithyjson.NewEncoder()
8027	if err := awsRestjson1_serializeOpDocumentUpdateThemeInput(input, jsonEncoder.Value); err != nil {
8028		return out, metadata, &smithy.SerializationError{Err: err}
8029	}
8030
8031	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8032		return out, metadata, &smithy.SerializationError{Err: err}
8033	}
8034
8035	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8036		return out, metadata, &smithy.SerializationError{Err: err}
8037	}
8038	in.Request = request
8039
8040	return next.HandleSerialize(ctx, in)
8041}
8042func awsRestjson1_serializeOpHttpBindingsUpdateThemeInput(v *UpdateThemeInput, encoder *httpbinding.Encoder) error {
8043	if v == nil {
8044		return fmt.Errorf("unsupported serialization of nil %T", v)
8045	}
8046
8047	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
8048		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
8049	}
8050	if v.AwsAccountId != nil {
8051		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
8052			return err
8053		}
8054	}
8055
8056	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
8057		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
8058	}
8059	if v.ThemeId != nil {
8060		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
8061			return err
8062		}
8063	}
8064
8065	return nil
8066}
8067
8068func awsRestjson1_serializeOpDocumentUpdateThemeInput(v *UpdateThemeInput, value smithyjson.Value) error {
8069	object := value.Object()
8070	defer object.Close()
8071
8072	if v.BaseThemeId != nil {
8073		ok := object.Key("BaseThemeId")
8074		ok.String(*v.BaseThemeId)
8075	}
8076
8077	if v.Configuration != nil {
8078		ok := object.Key("Configuration")
8079		if err := awsRestjson1_serializeDocumentThemeConfiguration(v.Configuration, ok); err != nil {
8080			return err
8081		}
8082	}
8083
8084	if v.Name != nil {
8085		ok := object.Key("Name")
8086		ok.String(*v.Name)
8087	}
8088
8089	if v.VersionDescription != nil {
8090		ok := object.Key("VersionDescription")
8091		ok.String(*v.VersionDescription)
8092	}
8093
8094	return nil
8095}
8096
8097type awsRestjson1_serializeOpUpdateThemeAlias struct {
8098}
8099
8100func (*awsRestjson1_serializeOpUpdateThemeAlias) ID() string {
8101	return "OperationSerializer"
8102}
8103
8104func (m *awsRestjson1_serializeOpUpdateThemeAlias) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8105	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8106) {
8107	request, ok := in.Request.(*smithyhttp.Request)
8108	if !ok {
8109		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8110	}
8111
8112	input, ok := in.Parameters.(*UpdateThemeAliasInput)
8113	_ = input
8114	if !ok {
8115		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8116	}
8117
8118	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/aliases/{AliasName}")
8119	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8120	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8121	request.Method = "PUT"
8122	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8123	if err != nil {
8124		return out, metadata, &smithy.SerializationError{Err: err}
8125	}
8126
8127	if err := awsRestjson1_serializeOpHttpBindingsUpdateThemeAliasInput(input, restEncoder); err != nil {
8128		return out, metadata, &smithy.SerializationError{Err: err}
8129	}
8130
8131	restEncoder.SetHeader("Content-Type").String("application/json")
8132
8133	jsonEncoder := smithyjson.NewEncoder()
8134	if err := awsRestjson1_serializeOpDocumentUpdateThemeAliasInput(input, jsonEncoder.Value); err != nil {
8135		return out, metadata, &smithy.SerializationError{Err: err}
8136	}
8137
8138	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8139		return out, metadata, &smithy.SerializationError{Err: err}
8140	}
8141
8142	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8143		return out, metadata, &smithy.SerializationError{Err: err}
8144	}
8145	in.Request = request
8146
8147	return next.HandleSerialize(ctx, in)
8148}
8149func awsRestjson1_serializeOpHttpBindingsUpdateThemeAliasInput(v *UpdateThemeAliasInput, encoder *httpbinding.Encoder) error {
8150	if v == nil {
8151		return fmt.Errorf("unsupported serialization of nil %T", v)
8152	}
8153
8154	if v.AliasName == nil || len(*v.AliasName) == 0 {
8155		return &smithy.SerializationError{Err: fmt.Errorf("input member AliasName must not be empty")}
8156	}
8157	if v.AliasName != nil {
8158		if err := encoder.SetURI("AliasName").String(*v.AliasName); err != nil {
8159			return err
8160		}
8161	}
8162
8163	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
8164		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
8165	}
8166	if v.AwsAccountId != nil {
8167		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
8168			return err
8169		}
8170	}
8171
8172	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
8173		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
8174	}
8175	if v.ThemeId != nil {
8176		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
8177			return err
8178		}
8179	}
8180
8181	return nil
8182}
8183
8184func awsRestjson1_serializeOpDocumentUpdateThemeAliasInput(v *UpdateThemeAliasInput, value smithyjson.Value) error {
8185	object := value.Object()
8186	defer object.Close()
8187
8188	if v.ThemeVersionNumber != nil {
8189		ok := object.Key("ThemeVersionNumber")
8190		ok.Long(*v.ThemeVersionNumber)
8191	}
8192
8193	return nil
8194}
8195
8196type awsRestjson1_serializeOpUpdateThemePermissions struct {
8197}
8198
8199func (*awsRestjson1_serializeOpUpdateThemePermissions) ID() string {
8200	return "OperationSerializer"
8201}
8202
8203func (m *awsRestjson1_serializeOpUpdateThemePermissions) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8204	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8205) {
8206	request, ok := in.Request.(*smithyhttp.Request)
8207	if !ok {
8208		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8209	}
8210
8211	input, ok := in.Parameters.(*UpdateThemePermissionsInput)
8212	_ = input
8213	if !ok {
8214		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8215	}
8216
8217	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/themes/{ThemeId}/permissions")
8218	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8219	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8220	request.Method = "PUT"
8221	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8222	if err != nil {
8223		return out, metadata, &smithy.SerializationError{Err: err}
8224	}
8225
8226	if err := awsRestjson1_serializeOpHttpBindingsUpdateThemePermissionsInput(input, restEncoder); err != nil {
8227		return out, metadata, &smithy.SerializationError{Err: err}
8228	}
8229
8230	restEncoder.SetHeader("Content-Type").String("application/json")
8231
8232	jsonEncoder := smithyjson.NewEncoder()
8233	if err := awsRestjson1_serializeOpDocumentUpdateThemePermissionsInput(input, jsonEncoder.Value); err != nil {
8234		return out, metadata, &smithy.SerializationError{Err: err}
8235	}
8236
8237	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8238		return out, metadata, &smithy.SerializationError{Err: err}
8239	}
8240
8241	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8242		return out, metadata, &smithy.SerializationError{Err: err}
8243	}
8244	in.Request = request
8245
8246	return next.HandleSerialize(ctx, in)
8247}
8248func awsRestjson1_serializeOpHttpBindingsUpdateThemePermissionsInput(v *UpdateThemePermissionsInput, encoder *httpbinding.Encoder) error {
8249	if v == nil {
8250		return fmt.Errorf("unsupported serialization of nil %T", v)
8251	}
8252
8253	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
8254		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
8255	}
8256	if v.AwsAccountId != nil {
8257		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
8258			return err
8259		}
8260	}
8261
8262	if v.ThemeId == nil || len(*v.ThemeId) == 0 {
8263		return &smithy.SerializationError{Err: fmt.Errorf("input member ThemeId must not be empty")}
8264	}
8265	if v.ThemeId != nil {
8266		if err := encoder.SetURI("ThemeId").String(*v.ThemeId); err != nil {
8267			return err
8268		}
8269	}
8270
8271	return nil
8272}
8273
8274func awsRestjson1_serializeOpDocumentUpdateThemePermissionsInput(v *UpdateThemePermissionsInput, value smithyjson.Value) error {
8275	object := value.Object()
8276	defer object.Close()
8277
8278	if v.GrantPermissions != nil {
8279		ok := object.Key("GrantPermissions")
8280		if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.GrantPermissions, ok); err != nil {
8281			return err
8282		}
8283	}
8284
8285	if v.RevokePermissions != nil {
8286		ok := object.Key("RevokePermissions")
8287		if err := awsRestjson1_serializeDocumentUpdateResourcePermissionList(v.RevokePermissions, ok); err != nil {
8288			return err
8289		}
8290	}
8291
8292	return nil
8293}
8294
8295type awsRestjson1_serializeOpUpdateUser struct {
8296}
8297
8298func (*awsRestjson1_serializeOpUpdateUser) ID() string {
8299	return "OperationSerializer"
8300}
8301
8302func (m *awsRestjson1_serializeOpUpdateUser) HandleSerialize(ctx context.Context, in middleware.SerializeInput, next middleware.SerializeHandler) (
8303	out middleware.SerializeOutput, metadata middleware.Metadata, err error,
8304) {
8305	request, ok := in.Request.(*smithyhttp.Request)
8306	if !ok {
8307		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown transport type %T", in.Request)}
8308	}
8309
8310	input, ok := in.Parameters.(*UpdateUserInput)
8311	_ = input
8312	if !ok {
8313		return out, metadata, &smithy.SerializationError{Err: fmt.Errorf("unknown input parameters type %T", in.Parameters)}
8314	}
8315
8316	opPath, opQuery := httpbinding.SplitURI("/accounts/{AwsAccountId}/namespaces/{Namespace}/users/{UserName}")
8317	request.URL.Path = smithyhttp.JoinPath(request.URL.Path, opPath)
8318	request.URL.RawQuery = smithyhttp.JoinRawQuery(request.URL.RawQuery, opQuery)
8319	request.Method = "PUT"
8320	restEncoder, err := httpbinding.NewEncoder(request.URL.Path, request.URL.RawQuery, request.Header)
8321	if err != nil {
8322		return out, metadata, &smithy.SerializationError{Err: err}
8323	}
8324
8325	if err := awsRestjson1_serializeOpHttpBindingsUpdateUserInput(input, restEncoder); err != nil {
8326		return out, metadata, &smithy.SerializationError{Err: err}
8327	}
8328
8329	restEncoder.SetHeader("Content-Type").String("application/json")
8330
8331	jsonEncoder := smithyjson.NewEncoder()
8332	if err := awsRestjson1_serializeOpDocumentUpdateUserInput(input, jsonEncoder.Value); err != nil {
8333		return out, metadata, &smithy.SerializationError{Err: err}
8334	}
8335
8336	if request, err = request.SetStream(bytes.NewReader(jsonEncoder.Bytes())); err != nil {
8337		return out, metadata, &smithy.SerializationError{Err: err}
8338	}
8339
8340	if request.Request, err = restEncoder.Encode(request.Request); err != nil {
8341		return out, metadata, &smithy.SerializationError{Err: err}
8342	}
8343	in.Request = request
8344
8345	return next.HandleSerialize(ctx, in)
8346}
8347func awsRestjson1_serializeOpHttpBindingsUpdateUserInput(v *UpdateUserInput, encoder *httpbinding.Encoder) error {
8348	if v == nil {
8349		return fmt.Errorf("unsupported serialization of nil %T", v)
8350	}
8351
8352	if v.AwsAccountId == nil || len(*v.AwsAccountId) == 0 {
8353		return &smithy.SerializationError{Err: fmt.Errorf("input member AwsAccountId must not be empty")}
8354	}
8355	if v.AwsAccountId != nil {
8356		if err := encoder.SetURI("AwsAccountId").String(*v.AwsAccountId); err != nil {
8357			return err
8358		}
8359	}
8360
8361	if v.Namespace == nil || len(*v.Namespace) == 0 {
8362		return &smithy.SerializationError{Err: fmt.Errorf("input member Namespace must not be empty")}
8363	}
8364	if v.Namespace != nil {
8365		if err := encoder.SetURI("Namespace").String(*v.Namespace); err != nil {
8366			return err
8367		}
8368	}
8369
8370	if v.UserName == nil || len(*v.UserName) == 0 {
8371		return &smithy.SerializationError{Err: fmt.Errorf("input member UserName must not be empty")}
8372	}
8373	if v.UserName != nil {
8374		if err := encoder.SetURI("UserName").String(*v.UserName); err != nil {
8375			return err
8376		}
8377	}
8378
8379	return nil
8380}
8381
8382func awsRestjson1_serializeOpDocumentUpdateUserInput(v *UpdateUserInput, value smithyjson.Value) error {
8383	object := value.Object()
8384	defer object.Close()
8385
8386	if v.CustomPermissionsName != nil {
8387		ok := object.Key("CustomPermissionsName")
8388		ok.String(*v.CustomPermissionsName)
8389	}
8390
8391	if v.Email != nil {
8392		ok := object.Key("Email")
8393		ok.String(*v.Email)
8394	}
8395
8396	if len(v.Role) > 0 {
8397		ok := object.Key("Role")
8398		ok.String(string(v.Role))
8399	}
8400
8401	if v.UnapplyCustomPermissions {
8402		ok := object.Key("UnapplyCustomPermissions")
8403		ok.Boolean(v.UnapplyCustomPermissions)
8404	}
8405
8406	return nil
8407}
8408
8409func awsRestjson1_serializeDocumentAccountCustomization(v *types.AccountCustomization, value smithyjson.Value) error {
8410	object := value.Object()
8411	defer object.Close()
8412
8413	if v.DefaultTheme != nil {
8414		ok := object.Key("DefaultTheme")
8415		ok.String(*v.DefaultTheme)
8416	}
8417
8418	return nil
8419}
8420
8421func awsRestjson1_serializeDocumentActionList(v []string, value smithyjson.Value) error {
8422	array := value.Array()
8423	defer array.Close()
8424
8425	for i := range v {
8426		av := array.Value()
8427		av.String(v[i])
8428	}
8429	return nil
8430}
8431
8432func awsRestjson1_serializeDocumentAdHocFilteringOption(v *types.AdHocFilteringOption, value smithyjson.Value) error {
8433	object := value.Object()
8434	defer object.Close()
8435
8436	if len(v.AvailabilityStatus) > 0 {
8437		ok := object.Key("AvailabilityStatus")
8438		ok.String(string(v.AvailabilityStatus))
8439	}
8440
8441	return nil
8442}
8443
8444func awsRestjson1_serializeDocumentAmazonElasticsearchParameters(v *types.AmazonElasticsearchParameters, value smithyjson.Value) error {
8445	object := value.Object()
8446	defer object.Close()
8447
8448	if v.Domain != nil {
8449		ok := object.Key("Domain")
8450		ok.String(*v.Domain)
8451	}
8452
8453	return nil
8454}
8455
8456func awsRestjson1_serializeDocumentAnalysisSearchFilter(v *types.AnalysisSearchFilter, value smithyjson.Value) error {
8457	object := value.Object()
8458	defer object.Close()
8459
8460	if len(v.Name) > 0 {
8461		ok := object.Key("Name")
8462		ok.String(string(v.Name))
8463	}
8464
8465	if len(v.Operator) > 0 {
8466		ok := object.Key("Operator")
8467		ok.String(string(v.Operator))
8468	}
8469
8470	if v.Value != nil {
8471		ok := object.Key("Value")
8472		ok.String(*v.Value)
8473	}
8474
8475	return nil
8476}
8477
8478func awsRestjson1_serializeDocumentAnalysisSearchFilterList(v []types.AnalysisSearchFilter, value smithyjson.Value) error {
8479	array := value.Array()
8480	defer array.Close()
8481
8482	for i := range v {
8483		av := array.Value()
8484		if err := awsRestjson1_serializeDocumentAnalysisSearchFilter(&v[i], av); err != nil {
8485			return err
8486		}
8487	}
8488	return nil
8489}
8490
8491func awsRestjson1_serializeDocumentAnalysisSourceEntity(v *types.AnalysisSourceEntity, value smithyjson.Value) error {
8492	object := value.Object()
8493	defer object.Close()
8494
8495	if v.SourceTemplate != nil {
8496		ok := object.Key("SourceTemplate")
8497		if err := awsRestjson1_serializeDocumentAnalysisSourceTemplate(v.SourceTemplate, ok); err != nil {
8498			return err
8499		}
8500	}
8501
8502	return nil
8503}
8504
8505func awsRestjson1_serializeDocumentAnalysisSourceTemplate(v *types.AnalysisSourceTemplate, value smithyjson.Value) error {
8506	object := value.Object()
8507	defer object.Close()
8508
8509	if v.Arn != nil {
8510		ok := object.Key("Arn")
8511		ok.String(*v.Arn)
8512	}
8513
8514	if v.DataSetReferences != nil {
8515		ok := object.Key("DataSetReferences")
8516		if err := awsRestjson1_serializeDocumentDataSetReferenceList(v.DataSetReferences, ok); err != nil {
8517			return err
8518		}
8519	}
8520
8521	return nil
8522}
8523
8524func awsRestjson1_serializeDocumentAthenaParameters(v *types.AthenaParameters, value smithyjson.Value) error {
8525	object := value.Object()
8526	defer object.Close()
8527
8528	if v.WorkGroup != nil {
8529		ok := object.Key("WorkGroup")
8530		ok.String(*v.WorkGroup)
8531	}
8532
8533	return nil
8534}
8535
8536func awsRestjson1_serializeDocumentAuroraParameters(v *types.AuroraParameters, value smithyjson.Value) error {
8537	object := value.Object()
8538	defer object.Close()
8539
8540	if v.Database != nil {
8541		ok := object.Key("Database")
8542		ok.String(*v.Database)
8543	}
8544
8545	if v.Host != nil {
8546		ok := object.Key("Host")
8547		ok.String(*v.Host)
8548	}
8549
8550	{
8551		ok := object.Key("Port")
8552		ok.Integer(v.Port)
8553	}
8554
8555	return nil
8556}
8557
8558func awsRestjson1_serializeDocumentAuroraPostgreSqlParameters(v *types.AuroraPostgreSqlParameters, value smithyjson.Value) error {
8559	object := value.Object()
8560	defer object.Close()
8561
8562	if v.Database != nil {
8563		ok := object.Key("Database")
8564		ok.String(*v.Database)
8565	}
8566
8567	if v.Host != nil {
8568		ok := object.Key("Host")
8569		ok.String(*v.Host)
8570	}
8571
8572	{
8573		ok := object.Key("Port")
8574		ok.Integer(v.Port)
8575	}
8576
8577	return nil
8578}
8579
8580func awsRestjson1_serializeDocumentAwsIotAnalyticsParameters(v *types.AwsIotAnalyticsParameters, value smithyjson.Value) error {
8581	object := value.Object()
8582	defer object.Close()
8583
8584	if v.DataSetName != nil {
8585		ok := object.Key("DataSetName")
8586		ok.String(*v.DataSetName)
8587	}
8588
8589	return nil
8590}
8591
8592func awsRestjson1_serializeDocumentBorderStyle(v *types.BorderStyle, value smithyjson.Value) error {
8593	object := value.Object()
8594	defer object.Close()
8595
8596	if v.Show {
8597		ok := object.Key("Show")
8598		ok.Boolean(v.Show)
8599	}
8600
8601	return nil
8602}
8603
8604func awsRestjson1_serializeDocumentCalculatedColumn(v *types.CalculatedColumn, value smithyjson.Value) error {
8605	object := value.Object()
8606	defer object.Close()
8607
8608	if v.ColumnId != nil {
8609		ok := object.Key("ColumnId")
8610		ok.String(*v.ColumnId)
8611	}
8612
8613	if v.ColumnName != nil {
8614		ok := object.Key("ColumnName")
8615		ok.String(*v.ColumnName)
8616	}
8617
8618	if v.Expression != nil {
8619		ok := object.Key("Expression")
8620		ok.String(*v.Expression)
8621	}
8622
8623	return nil
8624}
8625
8626func awsRestjson1_serializeDocumentCalculatedColumnList(v []types.CalculatedColumn, value smithyjson.Value) error {
8627	array := value.Array()
8628	defer array.Close()
8629
8630	for i := range v {
8631		av := array.Value()
8632		if err := awsRestjson1_serializeDocumentCalculatedColumn(&v[i], av); err != nil {
8633			return err
8634		}
8635	}
8636	return nil
8637}
8638
8639func awsRestjson1_serializeDocumentCastColumnTypeOperation(v *types.CastColumnTypeOperation, value smithyjson.Value) error {
8640	object := value.Object()
8641	defer object.Close()
8642
8643	if v.ColumnName != nil {
8644		ok := object.Key("ColumnName")
8645		ok.String(*v.ColumnName)
8646	}
8647
8648	if v.Format != nil {
8649		ok := object.Key("Format")
8650		ok.String(*v.Format)
8651	}
8652
8653	if len(v.NewColumnType) > 0 {
8654		ok := object.Key("NewColumnType")
8655		ok.String(string(v.NewColumnType))
8656	}
8657
8658	return nil
8659}
8660
8661func awsRestjson1_serializeDocumentColorList(v []string, value smithyjson.Value) error {
8662	array := value.Array()
8663	defer array.Close()
8664
8665	for i := range v {
8666		av := array.Value()
8667		av.String(v[i])
8668	}
8669	return nil
8670}
8671
8672func awsRestjson1_serializeDocumentColumnDescription(v *types.ColumnDescription, value smithyjson.Value) error {
8673	object := value.Object()
8674	defer object.Close()
8675
8676	if v.Text != nil {
8677		ok := object.Key("Text")
8678		ok.String(*v.Text)
8679	}
8680
8681	return nil
8682}
8683
8684func awsRestjson1_serializeDocumentColumnGroup(v *types.ColumnGroup, value smithyjson.Value) error {
8685	object := value.Object()
8686	defer object.Close()
8687
8688	if v.GeoSpatialColumnGroup != nil {
8689		ok := object.Key("GeoSpatialColumnGroup")
8690		if err := awsRestjson1_serializeDocumentGeoSpatialColumnGroup(v.GeoSpatialColumnGroup, ok); err != nil {
8691			return err
8692		}
8693	}
8694
8695	return nil
8696}
8697
8698func awsRestjson1_serializeDocumentColumnGroupList(v []types.ColumnGroup, value smithyjson.Value) error {
8699	array := value.Array()
8700	defer array.Close()
8701
8702	for i := range v {
8703		av := array.Value()
8704		if err := awsRestjson1_serializeDocumentColumnGroup(&v[i], av); err != nil {
8705			return err
8706		}
8707	}
8708	return nil
8709}
8710
8711func awsRestjson1_serializeDocumentColumnLevelPermissionRule(v *types.ColumnLevelPermissionRule, value smithyjson.Value) error {
8712	object := value.Object()
8713	defer object.Close()
8714
8715	if v.ColumnNames != nil {
8716		ok := object.Key("ColumnNames")
8717		if err := awsRestjson1_serializeDocumentColumnNameList(v.ColumnNames, ok); err != nil {
8718			return err
8719		}
8720	}
8721
8722	if v.Principals != nil {
8723		ok := object.Key("Principals")
8724		if err := awsRestjson1_serializeDocumentPrincipalList(v.Principals, ok); err != nil {
8725			return err
8726		}
8727	}
8728
8729	return nil
8730}
8731
8732func awsRestjson1_serializeDocumentColumnLevelPermissionRuleList(v []types.ColumnLevelPermissionRule, value smithyjson.Value) error {
8733	array := value.Array()
8734	defer array.Close()
8735
8736	for i := range v {
8737		av := array.Value()
8738		if err := awsRestjson1_serializeDocumentColumnLevelPermissionRule(&v[i], av); err != nil {
8739			return err
8740		}
8741	}
8742	return nil
8743}
8744
8745func awsRestjson1_serializeDocumentColumnList(v []string, value smithyjson.Value) error {
8746	array := value.Array()
8747	defer array.Close()
8748
8749	for i := range v {
8750		av := array.Value()
8751		av.String(v[i])
8752	}
8753	return nil
8754}
8755
8756func awsRestjson1_serializeDocumentColumnNameList(v []string, value smithyjson.Value) error {
8757	array := value.Array()
8758	defer array.Close()
8759
8760	for i := range v {
8761		av := array.Value()
8762		av.String(v[i])
8763	}
8764	return nil
8765}
8766
8767func awsRestjson1_serializeDocumentColumnTag(v *types.ColumnTag, value smithyjson.Value) error {
8768	object := value.Object()
8769	defer object.Close()
8770
8771	if v.ColumnDescription != nil {
8772		ok := object.Key("ColumnDescription")
8773		if err := awsRestjson1_serializeDocumentColumnDescription(v.ColumnDescription, ok); err != nil {
8774			return err
8775		}
8776	}
8777
8778	if len(v.ColumnGeographicRole) > 0 {
8779		ok := object.Key("ColumnGeographicRole")
8780		ok.String(string(v.ColumnGeographicRole))
8781	}
8782
8783	return nil
8784}
8785
8786func awsRestjson1_serializeDocumentColumnTagList(v []types.ColumnTag, value smithyjson.Value) error {
8787	array := value.Array()
8788	defer array.Close()
8789
8790	for i := range v {
8791		av := array.Value()
8792		if err := awsRestjson1_serializeDocumentColumnTag(&v[i], av); err != nil {
8793			return err
8794		}
8795	}
8796	return nil
8797}
8798
8799func awsRestjson1_serializeDocumentCreateColumnsOperation(v *types.CreateColumnsOperation, value smithyjson.Value) error {
8800	object := value.Object()
8801	defer object.Close()
8802
8803	if v.Columns != nil {
8804		ok := object.Key("Columns")
8805		if err := awsRestjson1_serializeDocumentCalculatedColumnList(v.Columns, ok); err != nil {
8806			return err
8807		}
8808	}
8809
8810	return nil
8811}
8812
8813func awsRestjson1_serializeDocumentCredentialPair(v *types.CredentialPair, value smithyjson.Value) error {
8814	object := value.Object()
8815	defer object.Close()
8816
8817	if v.AlternateDataSourceParameters != nil {
8818		ok := object.Key("AlternateDataSourceParameters")
8819		if err := awsRestjson1_serializeDocumentDataSourceParametersList(v.AlternateDataSourceParameters, ok); err != nil {
8820			return err
8821		}
8822	}
8823
8824	if v.Password != nil {
8825		ok := object.Key("Password")
8826		ok.String(*v.Password)
8827	}
8828
8829	if v.Username != nil {
8830		ok := object.Key("Username")
8831		ok.String(*v.Username)
8832	}
8833
8834	return nil
8835}
8836
8837func awsRestjson1_serializeDocumentCustomSql(v *types.CustomSql, value smithyjson.Value) error {
8838	object := value.Object()
8839	defer object.Close()
8840
8841	if v.Columns != nil {
8842		ok := object.Key("Columns")
8843		if err := awsRestjson1_serializeDocumentInputColumnList(v.Columns, ok); err != nil {
8844			return err
8845		}
8846	}
8847
8848	if v.DataSourceArn != nil {
8849		ok := object.Key("DataSourceArn")
8850		ok.String(*v.DataSourceArn)
8851	}
8852
8853	if v.Name != nil {
8854		ok := object.Key("Name")
8855		ok.String(*v.Name)
8856	}
8857
8858	if v.SqlQuery != nil {
8859		ok := object.Key("SqlQuery")
8860		ok.String(*v.SqlQuery)
8861	}
8862
8863	return nil
8864}
8865
8866func awsRestjson1_serializeDocumentDashboardPublishOptions(v *types.DashboardPublishOptions, value smithyjson.Value) error {
8867	object := value.Object()
8868	defer object.Close()
8869
8870	if v.AdHocFilteringOption != nil {
8871		ok := object.Key("AdHocFilteringOption")
8872		if err := awsRestjson1_serializeDocumentAdHocFilteringOption(v.AdHocFilteringOption, ok); err != nil {
8873			return err
8874		}
8875	}
8876
8877	if v.ExportToCSVOption != nil {
8878		ok := object.Key("ExportToCSVOption")
8879		if err := awsRestjson1_serializeDocumentExportToCSVOption(v.ExportToCSVOption, ok); err != nil {
8880			return err
8881		}
8882	}
8883
8884	if v.SheetControlsOption != nil {
8885		ok := object.Key("SheetControlsOption")
8886		if err := awsRestjson1_serializeDocumentSheetControlsOption(v.SheetControlsOption, ok); err != nil {
8887			return err
8888		}
8889	}
8890
8891	return nil
8892}
8893
8894func awsRestjson1_serializeDocumentDashboardSearchFilter(v *types.DashboardSearchFilter, value smithyjson.Value) error {
8895	object := value.Object()
8896	defer object.Close()
8897
8898	if len(v.Name) > 0 {
8899		ok := object.Key("Name")
8900		ok.String(string(v.Name))
8901	}
8902
8903	if len(v.Operator) > 0 {
8904		ok := object.Key("Operator")
8905		ok.String(string(v.Operator))
8906	}
8907
8908	if v.Value != nil {
8909		ok := object.Key("Value")
8910		ok.String(*v.Value)
8911	}
8912
8913	return nil
8914}
8915
8916func awsRestjson1_serializeDocumentDashboardSearchFilterList(v []types.DashboardSearchFilter, value smithyjson.Value) error {
8917	array := value.Array()
8918	defer array.Close()
8919
8920	for i := range v {
8921		av := array.Value()
8922		if err := awsRestjson1_serializeDocumentDashboardSearchFilter(&v[i], av); err != nil {
8923			return err
8924		}
8925	}
8926	return nil
8927}
8928
8929func awsRestjson1_serializeDocumentDashboardSourceEntity(v *types.DashboardSourceEntity, value smithyjson.Value) error {
8930	object := value.Object()
8931	defer object.Close()
8932
8933	if v.SourceTemplate != nil {
8934		ok := object.Key("SourceTemplate")
8935		if err := awsRestjson1_serializeDocumentDashboardSourceTemplate(v.SourceTemplate, ok); err != nil {
8936			return err
8937		}
8938	}
8939
8940	return nil
8941}
8942
8943func awsRestjson1_serializeDocumentDashboardSourceTemplate(v *types.DashboardSourceTemplate, value smithyjson.Value) error {
8944	object := value.Object()
8945	defer object.Close()
8946
8947	if v.Arn != nil {
8948		ok := object.Key("Arn")
8949		ok.String(*v.Arn)
8950	}
8951
8952	if v.DataSetReferences != nil {
8953		ok := object.Key("DataSetReferences")
8954		if err := awsRestjson1_serializeDocumentDataSetReferenceList(v.DataSetReferences, ok); err != nil {
8955			return err
8956		}
8957	}
8958
8959	return nil
8960}
8961
8962func awsRestjson1_serializeDocumentDataColorPalette(v *types.DataColorPalette, value smithyjson.Value) error {
8963	object := value.Object()
8964	defer object.Close()
8965
8966	if v.Colors != nil {
8967		ok := object.Key("Colors")
8968		if err := awsRestjson1_serializeDocumentColorList(v.Colors, ok); err != nil {
8969			return err
8970		}
8971	}
8972
8973	if v.EmptyFillColor != nil {
8974		ok := object.Key("EmptyFillColor")
8975		ok.String(*v.EmptyFillColor)
8976	}
8977
8978	if v.MinMaxGradient != nil {
8979		ok := object.Key("MinMaxGradient")
8980		if err := awsRestjson1_serializeDocumentColorList(v.MinMaxGradient, ok); err != nil {
8981			return err
8982		}
8983	}
8984
8985	return nil
8986}
8987
8988func awsRestjson1_serializeDocumentDataSetReference(v *types.DataSetReference, value smithyjson.Value) error {
8989	object := value.Object()
8990	defer object.Close()
8991
8992	if v.DataSetArn != nil {
8993		ok := object.Key("DataSetArn")
8994		ok.String(*v.DataSetArn)
8995	}
8996
8997	if v.DataSetPlaceholder != nil {
8998		ok := object.Key("DataSetPlaceholder")
8999		ok.String(*v.DataSetPlaceholder)
9000	}
9001
9002	return nil
9003}
9004
9005func awsRestjson1_serializeDocumentDataSetReferenceList(v []types.DataSetReference, value smithyjson.Value) error {
9006	array := value.Array()
9007	defer array.Close()
9008
9009	for i := range v {
9010		av := array.Value()
9011		if err := awsRestjson1_serializeDocumentDataSetReference(&v[i], av); err != nil {
9012			return err
9013		}
9014	}
9015	return nil
9016}
9017
9018func awsRestjson1_serializeDocumentDataSourceCredentials(v *types.DataSourceCredentials, value smithyjson.Value) error {
9019	object := value.Object()
9020	defer object.Close()
9021
9022	if v.CopySourceArn != nil {
9023		ok := object.Key("CopySourceArn")
9024		ok.String(*v.CopySourceArn)
9025	}
9026
9027	if v.CredentialPair != nil {
9028		ok := object.Key("CredentialPair")
9029		if err := awsRestjson1_serializeDocumentCredentialPair(v.CredentialPair, ok); err != nil {
9030			return err
9031		}
9032	}
9033
9034	return nil
9035}
9036
9037func awsRestjson1_serializeDocumentDataSourceParameters(v types.DataSourceParameters, value smithyjson.Value) error {
9038	object := value.Object()
9039	defer object.Close()
9040
9041	switch uv := v.(type) {
9042	case *types.DataSourceParametersMemberAmazonElasticsearchParameters:
9043		av := object.Key("AmazonElasticsearchParameters")
9044		if err := awsRestjson1_serializeDocumentAmazonElasticsearchParameters(&uv.Value, av); err != nil {
9045			return err
9046		}
9047
9048	case *types.DataSourceParametersMemberAthenaParameters:
9049		av := object.Key("AthenaParameters")
9050		if err := awsRestjson1_serializeDocumentAthenaParameters(&uv.Value, av); err != nil {
9051			return err
9052		}
9053
9054	case *types.DataSourceParametersMemberAuroraParameters:
9055		av := object.Key("AuroraParameters")
9056		if err := awsRestjson1_serializeDocumentAuroraParameters(&uv.Value, av); err != nil {
9057			return err
9058		}
9059
9060	case *types.DataSourceParametersMemberAuroraPostgreSqlParameters:
9061		av := object.Key("AuroraPostgreSqlParameters")
9062		if err := awsRestjson1_serializeDocumentAuroraPostgreSqlParameters(&uv.Value, av); err != nil {
9063			return err
9064		}
9065
9066	case *types.DataSourceParametersMemberAwsIotAnalyticsParameters:
9067		av := object.Key("AwsIotAnalyticsParameters")
9068		if err := awsRestjson1_serializeDocumentAwsIotAnalyticsParameters(&uv.Value, av); err != nil {
9069			return err
9070		}
9071
9072	case *types.DataSourceParametersMemberJiraParameters:
9073		av := object.Key("JiraParameters")
9074		if err := awsRestjson1_serializeDocumentJiraParameters(&uv.Value, av); err != nil {
9075			return err
9076		}
9077
9078	case *types.DataSourceParametersMemberMariaDbParameters:
9079		av := object.Key("MariaDbParameters")
9080		if err := awsRestjson1_serializeDocumentMariaDbParameters(&uv.Value, av); err != nil {
9081			return err
9082		}
9083
9084	case *types.DataSourceParametersMemberMySqlParameters:
9085		av := object.Key("MySqlParameters")
9086		if err := awsRestjson1_serializeDocumentMySqlParameters(&uv.Value, av); err != nil {
9087			return err
9088		}
9089
9090	case *types.DataSourceParametersMemberOracleParameters:
9091		av := object.Key("OracleParameters")
9092		if err := awsRestjson1_serializeDocumentOracleParameters(&uv.Value, av); err != nil {
9093			return err
9094		}
9095
9096	case *types.DataSourceParametersMemberPostgreSqlParameters:
9097		av := object.Key("PostgreSqlParameters")
9098		if err := awsRestjson1_serializeDocumentPostgreSqlParameters(&uv.Value, av); err != nil {
9099			return err
9100		}
9101
9102	case *types.DataSourceParametersMemberPrestoParameters:
9103		av := object.Key("PrestoParameters")
9104		if err := awsRestjson1_serializeDocumentPrestoParameters(&uv.Value, av); err != nil {
9105			return err
9106		}
9107
9108	case *types.DataSourceParametersMemberRdsParameters:
9109		av := object.Key("RdsParameters")
9110		if err := awsRestjson1_serializeDocumentRdsParameters(&uv.Value, av); err != nil {
9111			return err
9112		}
9113
9114	case *types.DataSourceParametersMemberRedshiftParameters:
9115		av := object.Key("RedshiftParameters")
9116		if err := awsRestjson1_serializeDocumentRedshiftParameters(&uv.Value, av); err != nil {
9117			return err
9118		}
9119
9120	case *types.DataSourceParametersMemberS3Parameters:
9121		av := object.Key("S3Parameters")
9122		if err := awsRestjson1_serializeDocumentS3Parameters(&uv.Value, av); err != nil {
9123			return err
9124		}
9125
9126	case *types.DataSourceParametersMemberServiceNowParameters:
9127		av := object.Key("ServiceNowParameters")
9128		if err := awsRestjson1_serializeDocumentServiceNowParameters(&uv.Value, av); err != nil {
9129			return err
9130		}
9131
9132	case *types.DataSourceParametersMemberSnowflakeParameters:
9133		av := object.Key("SnowflakeParameters")
9134		if err := awsRestjson1_serializeDocumentSnowflakeParameters(&uv.Value, av); err != nil {
9135			return err
9136		}
9137
9138	case *types.DataSourceParametersMemberSparkParameters:
9139		av := object.Key("SparkParameters")
9140		if err := awsRestjson1_serializeDocumentSparkParameters(&uv.Value, av); err != nil {
9141			return err
9142		}
9143
9144	case *types.DataSourceParametersMemberSqlServerParameters:
9145		av := object.Key("SqlServerParameters")
9146		if err := awsRestjson1_serializeDocumentSqlServerParameters(&uv.Value, av); err != nil {
9147			return err
9148		}
9149
9150	case *types.DataSourceParametersMemberTeradataParameters:
9151		av := object.Key("TeradataParameters")
9152		if err := awsRestjson1_serializeDocumentTeradataParameters(&uv.Value, av); err != nil {
9153			return err
9154		}
9155
9156	case *types.DataSourceParametersMemberTwitterParameters:
9157		av := object.Key("TwitterParameters")
9158		if err := awsRestjson1_serializeDocumentTwitterParameters(&uv.Value, av); err != nil {
9159			return err
9160		}
9161
9162	default:
9163		return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
9164
9165	}
9166	return nil
9167}
9168
9169func awsRestjson1_serializeDocumentDataSourceParametersList(v []types.DataSourceParameters, value smithyjson.Value) error {
9170	array := value.Array()
9171	defer array.Close()
9172
9173	for i := range v {
9174		av := array.Value()
9175		if vv := v[i]; vv == nil {
9176			continue
9177		}
9178		if err := awsRestjson1_serializeDocumentDataSourceParameters(v[i], av); err != nil {
9179			return err
9180		}
9181	}
9182	return nil
9183}
9184
9185func awsRestjson1_serializeDocumentDateTimeParameter(v *types.DateTimeParameter, value smithyjson.Value) error {
9186	object := value.Object()
9187	defer object.Close()
9188
9189	if v.Name != nil {
9190		ok := object.Key("Name")
9191		ok.String(*v.Name)
9192	}
9193
9194	if v.Values != nil {
9195		ok := object.Key("Values")
9196		if err := awsRestjson1_serializeDocumentTimestampList(v.Values, ok); err != nil {
9197			return err
9198		}
9199	}
9200
9201	return nil
9202}
9203
9204func awsRestjson1_serializeDocumentDateTimeParameterList(v []types.DateTimeParameter, value smithyjson.Value) error {
9205	array := value.Array()
9206	defer array.Close()
9207
9208	for i := range v {
9209		av := array.Value()
9210		if err := awsRestjson1_serializeDocumentDateTimeParameter(&v[i], av); err != nil {
9211			return err
9212		}
9213	}
9214	return nil
9215}
9216
9217func awsRestjson1_serializeDocumentDecimalParameter(v *types.DecimalParameter, value smithyjson.Value) error {
9218	object := value.Object()
9219	defer object.Close()
9220
9221	if v.Name != nil {
9222		ok := object.Key("Name")
9223		ok.String(*v.Name)
9224	}
9225
9226	if v.Values != nil {
9227		ok := object.Key("Values")
9228		if err := awsRestjson1_serializeDocumentDoubleList(v.Values, ok); err != nil {
9229			return err
9230		}
9231	}
9232
9233	return nil
9234}
9235
9236func awsRestjson1_serializeDocumentDecimalParameterList(v []types.DecimalParameter, value smithyjson.Value) error {
9237	array := value.Array()
9238	defer array.Close()
9239
9240	for i := range v {
9241		av := array.Value()
9242		if err := awsRestjson1_serializeDocumentDecimalParameter(&v[i], av); err != nil {
9243			return err
9244		}
9245	}
9246	return nil
9247}
9248
9249func awsRestjson1_serializeDocumentDoubleList(v []float64, value smithyjson.Value) error {
9250	array := value.Array()
9251	defer array.Close()
9252
9253	for i := range v {
9254		av := array.Value()
9255		av.Double(v[i])
9256	}
9257	return nil
9258}
9259
9260func awsRestjson1_serializeDocumentExportToCSVOption(v *types.ExportToCSVOption, value smithyjson.Value) error {
9261	object := value.Object()
9262	defer object.Close()
9263
9264	if len(v.AvailabilityStatus) > 0 {
9265		ok := object.Key("AvailabilityStatus")
9266		ok.String(string(v.AvailabilityStatus))
9267	}
9268
9269	return nil
9270}
9271
9272func awsRestjson1_serializeDocumentFieldFolder(v *types.FieldFolder, value smithyjson.Value) error {
9273	object := value.Object()
9274	defer object.Close()
9275
9276	if v.Columns != nil {
9277		ok := object.Key("columns")
9278		if err := awsRestjson1_serializeDocumentFolderColumnList(v.Columns, ok); err != nil {
9279			return err
9280		}
9281	}
9282
9283	if v.Description != nil {
9284		ok := object.Key("description")
9285		ok.String(*v.Description)
9286	}
9287
9288	return nil
9289}
9290
9291func awsRestjson1_serializeDocumentFieldFolderMap(v map[string]types.FieldFolder, value smithyjson.Value) error {
9292	object := value.Object()
9293	defer object.Close()
9294
9295	for key := range v {
9296		om := object.Key(key)
9297		mapVar := v[key]
9298		if err := awsRestjson1_serializeDocumentFieldFolder(&mapVar, om); err != nil {
9299			return err
9300		}
9301	}
9302	return nil
9303}
9304
9305func awsRestjson1_serializeDocumentFilterOperation(v *types.FilterOperation, value smithyjson.Value) error {
9306	object := value.Object()
9307	defer object.Close()
9308
9309	if v.ConditionExpression != nil {
9310		ok := object.Key("ConditionExpression")
9311		ok.String(*v.ConditionExpression)
9312	}
9313
9314	return nil
9315}
9316
9317func awsRestjson1_serializeDocumentFolderColumnList(v []string, value smithyjson.Value) error {
9318	array := value.Array()
9319	defer array.Close()
9320
9321	for i := range v {
9322		av := array.Value()
9323		av.String(v[i])
9324	}
9325	return nil
9326}
9327
9328func awsRestjson1_serializeDocumentGeoSpatialColumnGroup(v *types.GeoSpatialColumnGroup, value smithyjson.Value) error {
9329	object := value.Object()
9330	defer object.Close()
9331
9332	if v.Columns != nil {
9333		ok := object.Key("Columns")
9334		if err := awsRestjson1_serializeDocumentColumnList(v.Columns, ok); err != nil {
9335			return err
9336		}
9337	}
9338
9339	if len(v.CountryCode) > 0 {
9340		ok := object.Key("CountryCode")
9341		ok.String(string(v.CountryCode))
9342	}
9343
9344	if v.Name != nil {
9345		ok := object.Key("Name")
9346		ok.String(*v.Name)
9347	}
9348
9349	return nil
9350}
9351
9352func awsRestjson1_serializeDocumentGutterStyle(v *types.GutterStyle, value smithyjson.Value) error {
9353	object := value.Object()
9354	defer object.Close()
9355
9356	if v.Show {
9357		ok := object.Key("Show")
9358		ok.Boolean(v.Show)
9359	}
9360
9361	return nil
9362}
9363
9364func awsRestjson1_serializeDocumentIdentityMap(v map[string][]string, value smithyjson.Value) error {
9365	object := value.Object()
9366	defer object.Close()
9367
9368	for key := range v {
9369		om := object.Key(key)
9370		if vv := v[key]; vv == nil {
9371			continue
9372		}
9373		if err := awsRestjson1_serializeDocumentIdentityNameList(v[key], om); err != nil {
9374			return err
9375		}
9376	}
9377	return nil
9378}
9379
9380func awsRestjson1_serializeDocumentIdentityNameList(v []string, value smithyjson.Value) error {
9381	array := value.Array()
9382	defer array.Close()
9383
9384	for i := range v {
9385		av := array.Value()
9386		av.String(v[i])
9387	}
9388	return nil
9389}
9390
9391func awsRestjson1_serializeDocumentInputColumn(v *types.InputColumn, value smithyjson.Value) error {
9392	object := value.Object()
9393	defer object.Close()
9394
9395	if v.Name != nil {
9396		ok := object.Key("Name")
9397		ok.String(*v.Name)
9398	}
9399
9400	if len(v.Type) > 0 {
9401		ok := object.Key("Type")
9402		ok.String(string(v.Type))
9403	}
9404
9405	return nil
9406}
9407
9408func awsRestjson1_serializeDocumentInputColumnList(v []types.InputColumn, value smithyjson.Value) error {
9409	array := value.Array()
9410	defer array.Close()
9411
9412	for i := range v {
9413		av := array.Value()
9414		if err := awsRestjson1_serializeDocumentInputColumn(&v[i], av); err != nil {
9415			return err
9416		}
9417	}
9418	return nil
9419}
9420
9421func awsRestjson1_serializeDocumentIntegerParameter(v *types.IntegerParameter, value smithyjson.Value) error {
9422	object := value.Object()
9423	defer object.Close()
9424
9425	if v.Name != nil {
9426		ok := object.Key("Name")
9427		ok.String(*v.Name)
9428	}
9429
9430	if v.Values != nil {
9431		ok := object.Key("Values")
9432		if err := awsRestjson1_serializeDocumentLongList(v.Values, ok); err != nil {
9433			return err
9434		}
9435	}
9436
9437	return nil
9438}
9439
9440func awsRestjson1_serializeDocumentIntegerParameterList(v []types.IntegerParameter, value smithyjson.Value) error {
9441	array := value.Array()
9442	defer array.Close()
9443
9444	for i := range v {
9445		av := array.Value()
9446		if err := awsRestjson1_serializeDocumentIntegerParameter(&v[i], av); err != nil {
9447			return err
9448		}
9449	}
9450	return nil
9451}
9452
9453func awsRestjson1_serializeDocumentJiraParameters(v *types.JiraParameters, value smithyjson.Value) error {
9454	object := value.Object()
9455	defer object.Close()
9456
9457	if v.SiteBaseUrl != nil {
9458		ok := object.Key("SiteBaseUrl")
9459		ok.String(*v.SiteBaseUrl)
9460	}
9461
9462	return nil
9463}
9464
9465func awsRestjson1_serializeDocumentJoinInstruction(v *types.JoinInstruction, value smithyjson.Value) error {
9466	object := value.Object()
9467	defer object.Close()
9468
9469	if v.LeftJoinKeyProperties != nil {
9470		ok := object.Key("LeftJoinKeyProperties")
9471		if err := awsRestjson1_serializeDocumentJoinKeyProperties(v.LeftJoinKeyProperties, ok); err != nil {
9472			return err
9473		}
9474	}
9475
9476	if v.LeftOperand != nil {
9477		ok := object.Key("LeftOperand")
9478		ok.String(*v.LeftOperand)
9479	}
9480
9481	if v.OnClause != nil {
9482		ok := object.Key("OnClause")
9483		ok.String(*v.OnClause)
9484	}
9485
9486	if v.RightJoinKeyProperties != nil {
9487		ok := object.Key("RightJoinKeyProperties")
9488		if err := awsRestjson1_serializeDocumentJoinKeyProperties(v.RightJoinKeyProperties, ok); err != nil {
9489			return err
9490		}
9491	}
9492
9493	if v.RightOperand != nil {
9494		ok := object.Key("RightOperand")
9495		ok.String(*v.RightOperand)
9496	}
9497
9498	if len(v.Type) > 0 {
9499		ok := object.Key("Type")
9500		ok.String(string(v.Type))
9501	}
9502
9503	return nil
9504}
9505
9506func awsRestjson1_serializeDocumentJoinKeyProperties(v *types.JoinKeyProperties, value smithyjson.Value) error {
9507	object := value.Object()
9508	defer object.Close()
9509
9510	if v.UniqueKey {
9511		ok := object.Key("UniqueKey")
9512		ok.Boolean(v.UniqueKey)
9513	}
9514
9515	return nil
9516}
9517
9518func awsRestjson1_serializeDocumentLogicalTable(v *types.LogicalTable, value smithyjson.Value) error {
9519	object := value.Object()
9520	defer object.Close()
9521
9522	if v.Alias != nil {
9523		ok := object.Key("Alias")
9524		ok.String(*v.Alias)
9525	}
9526
9527	if v.DataTransforms != nil {
9528		ok := object.Key("DataTransforms")
9529		if err := awsRestjson1_serializeDocumentTransformOperationList(v.DataTransforms, ok); err != nil {
9530			return err
9531		}
9532	}
9533
9534	if v.Source != nil {
9535		ok := object.Key("Source")
9536		if err := awsRestjson1_serializeDocumentLogicalTableSource(v.Source, ok); err != nil {
9537			return err
9538		}
9539	}
9540
9541	return nil
9542}
9543
9544func awsRestjson1_serializeDocumentLogicalTableMap(v map[string]types.LogicalTable, value smithyjson.Value) error {
9545	object := value.Object()
9546	defer object.Close()
9547
9548	for key := range v {
9549		om := object.Key(key)
9550		mapVar := v[key]
9551		if err := awsRestjson1_serializeDocumentLogicalTable(&mapVar, om); err != nil {
9552			return err
9553		}
9554	}
9555	return nil
9556}
9557
9558func awsRestjson1_serializeDocumentLogicalTableSource(v *types.LogicalTableSource, value smithyjson.Value) error {
9559	object := value.Object()
9560	defer object.Close()
9561
9562	if v.JoinInstruction != nil {
9563		ok := object.Key("JoinInstruction")
9564		if err := awsRestjson1_serializeDocumentJoinInstruction(v.JoinInstruction, ok); err != nil {
9565			return err
9566		}
9567	}
9568
9569	if v.PhysicalTableId != nil {
9570		ok := object.Key("PhysicalTableId")
9571		ok.String(*v.PhysicalTableId)
9572	}
9573
9574	return nil
9575}
9576
9577func awsRestjson1_serializeDocumentLongList(v []int64, value smithyjson.Value) error {
9578	array := value.Array()
9579	defer array.Close()
9580
9581	for i := range v {
9582		av := array.Value()
9583		av.Long(v[i])
9584	}
9585	return nil
9586}
9587
9588func awsRestjson1_serializeDocumentManifestFileLocation(v *types.ManifestFileLocation, value smithyjson.Value) error {
9589	object := value.Object()
9590	defer object.Close()
9591
9592	if v.Bucket != nil {
9593		ok := object.Key("Bucket")
9594		ok.String(*v.Bucket)
9595	}
9596
9597	if v.Key != nil {
9598		ok := object.Key("Key")
9599		ok.String(*v.Key)
9600	}
9601
9602	return nil
9603}
9604
9605func awsRestjson1_serializeDocumentMarginStyle(v *types.MarginStyle, value smithyjson.Value) error {
9606	object := value.Object()
9607	defer object.Close()
9608
9609	if v.Show {
9610		ok := object.Key("Show")
9611		ok.Boolean(v.Show)
9612	}
9613
9614	return nil
9615}
9616
9617func awsRestjson1_serializeDocumentMariaDbParameters(v *types.MariaDbParameters, value smithyjson.Value) error {
9618	object := value.Object()
9619	defer object.Close()
9620
9621	if v.Database != nil {
9622		ok := object.Key("Database")
9623		ok.String(*v.Database)
9624	}
9625
9626	if v.Host != nil {
9627		ok := object.Key("Host")
9628		ok.String(*v.Host)
9629	}
9630
9631	{
9632		ok := object.Key("Port")
9633		ok.Integer(v.Port)
9634	}
9635
9636	return nil
9637}
9638
9639func awsRestjson1_serializeDocumentMySqlParameters(v *types.MySqlParameters, value smithyjson.Value) error {
9640	object := value.Object()
9641	defer object.Close()
9642
9643	if v.Database != nil {
9644		ok := object.Key("Database")
9645		ok.String(*v.Database)
9646	}
9647
9648	if v.Host != nil {
9649		ok := object.Key("Host")
9650		ok.String(*v.Host)
9651	}
9652
9653	{
9654		ok := object.Key("Port")
9655		ok.Integer(v.Port)
9656	}
9657
9658	return nil
9659}
9660
9661func awsRestjson1_serializeDocumentOracleParameters(v *types.OracleParameters, value smithyjson.Value) error {
9662	object := value.Object()
9663	defer object.Close()
9664
9665	if v.Database != nil {
9666		ok := object.Key("Database")
9667		ok.String(*v.Database)
9668	}
9669
9670	if v.Host != nil {
9671		ok := object.Key("Host")
9672		ok.String(*v.Host)
9673	}
9674
9675	{
9676		ok := object.Key("Port")
9677		ok.Integer(v.Port)
9678	}
9679
9680	return nil
9681}
9682
9683func awsRestjson1_serializeDocumentParameters(v *types.Parameters, value smithyjson.Value) error {
9684	object := value.Object()
9685	defer object.Close()
9686
9687	if v.DateTimeParameters != nil {
9688		ok := object.Key("DateTimeParameters")
9689		if err := awsRestjson1_serializeDocumentDateTimeParameterList(v.DateTimeParameters, ok); err != nil {
9690			return err
9691		}
9692	}
9693
9694	if v.DecimalParameters != nil {
9695		ok := object.Key("DecimalParameters")
9696		if err := awsRestjson1_serializeDocumentDecimalParameterList(v.DecimalParameters, ok); err != nil {
9697			return err
9698		}
9699	}
9700
9701	if v.IntegerParameters != nil {
9702		ok := object.Key("IntegerParameters")
9703		if err := awsRestjson1_serializeDocumentIntegerParameterList(v.IntegerParameters, ok); err != nil {
9704			return err
9705		}
9706	}
9707
9708	if v.StringParameters != nil {
9709		ok := object.Key("StringParameters")
9710		if err := awsRestjson1_serializeDocumentStringParameterList(v.StringParameters, ok); err != nil {
9711			return err
9712		}
9713	}
9714
9715	return nil
9716}
9717
9718func awsRestjson1_serializeDocumentPhysicalTable(v types.PhysicalTable, value smithyjson.Value) error {
9719	object := value.Object()
9720	defer object.Close()
9721
9722	switch uv := v.(type) {
9723	case *types.PhysicalTableMemberCustomSql:
9724		av := object.Key("CustomSql")
9725		if err := awsRestjson1_serializeDocumentCustomSql(&uv.Value, av); err != nil {
9726			return err
9727		}
9728
9729	case *types.PhysicalTableMemberRelationalTable:
9730		av := object.Key("RelationalTable")
9731		if err := awsRestjson1_serializeDocumentRelationalTable(&uv.Value, av); err != nil {
9732			return err
9733		}
9734
9735	case *types.PhysicalTableMemberS3Source:
9736		av := object.Key("S3Source")
9737		if err := awsRestjson1_serializeDocumentS3Source(&uv.Value, av); err != nil {
9738			return err
9739		}
9740
9741	default:
9742		return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
9743
9744	}
9745	return nil
9746}
9747
9748func awsRestjson1_serializeDocumentPhysicalTableMap(v map[string]types.PhysicalTable, value smithyjson.Value) error {
9749	object := value.Object()
9750	defer object.Close()
9751
9752	for key := range v {
9753		om := object.Key(key)
9754		if vv := v[key]; vv == nil {
9755			continue
9756		}
9757		if err := awsRestjson1_serializeDocumentPhysicalTable(v[key], om); err != nil {
9758			return err
9759		}
9760	}
9761	return nil
9762}
9763
9764func awsRestjson1_serializeDocumentPostgreSqlParameters(v *types.PostgreSqlParameters, value smithyjson.Value) error {
9765	object := value.Object()
9766	defer object.Close()
9767
9768	if v.Database != nil {
9769		ok := object.Key("Database")
9770		ok.String(*v.Database)
9771	}
9772
9773	if v.Host != nil {
9774		ok := object.Key("Host")
9775		ok.String(*v.Host)
9776	}
9777
9778	{
9779		ok := object.Key("Port")
9780		ok.Integer(v.Port)
9781	}
9782
9783	return nil
9784}
9785
9786func awsRestjson1_serializeDocumentPrestoParameters(v *types.PrestoParameters, value smithyjson.Value) error {
9787	object := value.Object()
9788	defer object.Close()
9789
9790	if v.Catalog != nil {
9791		ok := object.Key("Catalog")
9792		ok.String(*v.Catalog)
9793	}
9794
9795	if v.Host != nil {
9796		ok := object.Key("Host")
9797		ok.String(*v.Host)
9798	}
9799
9800	{
9801		ok := object.Key("Port")
9802		ok.Integer(v.Port)
9803	}
9804
9805	return nil
9806}
9807
9808func awsRestjson1_serializeDocumentPrincipalList(v []string, value smithyjson.Value) error {
9809	array := value.Array()
9810	defer array.Close()
9811
9812	for i := range v {
9813		av := array.Value()
9814		av.String(v[i])
9815	}
9816	return nil
9817}
9818
9819func awsRestjson1_serializeDocumentProjectedColumnList(v []string, value smithyjson.Value) error {
9820	array := value.Array()
9821	defer array.Close()
9822
9823	for i := range v {
9824		av := array.Value()
9825		av.String(v[i])
9826	}
9827	return nil
9828}
9829
9830func awsRestjson1_serializeDocumentProjectOperation(v *types.ProjectOperation, value smithyjson.Value) error {
9831	object := value.Object()
9832	defer object.Close()
9833
9834	if v.ProjectedColumns != nil {
9835		ok := object.Key("ProjectedColumns")
9836		if err := awsRestjson1_serializeDocumentProjectedColumnList(v.ProjectedColumns, ok); err != nil {
9837			return err
9838		}
9839	}
9840
9841	return nil
9842}
9843
9844func awsRestjson1_serializeDocumentRdsParameters(v *types.RdsParameters, value smithyjson.Value) error {
9845	object := value.Object()
9846	defer object.Close()
9847
9848	if v.Database != nil {
9849		ok := object.Key("Database")
9850		ok.String(*v.Database)
9851	}
9852
9853	if v.InstanceId != nil {
9854		ok := object.Key("InstanceId")
9855		ok.String(*v.InstanceId)
9856	}
9857
9858	return nil
9859}
9860
9861func awsRestjson1_serializeDocumentRedshiftParameters(v *types.RedshiftParameters, value smithyjson.Value) error {
9862	object := value.Object()
9863	defer object.Close()
9864
9865	if v.ClusterId != nil {
9866		ok := object.Key("ClusterId")
9867		ok.String(*v.ClusterId)
9868	}
9869
9870	if v.Database != nil {
9871		ok := object.Key("Database")
9872		ok.String(*v.Database)
9873	}
9874
9875	if v.Host != nil {
9876		ok := object.Key("Host")
9877		ok.String(*v.Host)
9878	}
9879
9880	if v.Port != 0 {
9881		ok := object.Key("Port")
9882		ok.Integer(v.Port)
9883	}
9884
9885	return nil
9886}
9887
9888func awsRestjson1_serializeDocumentRelationalTable(v *types.RelationalTable, value smithyjson.Value) error {
9889	object := value.Object()
9890	defer object.Close()
9891
9892	if v.Catalog != nil {
9893		ok := object.Key("Catalog")
9894		ok.String(*v.Catalog)
9895	}
9896
9897	if v.DataSourceArn != nil {
9898		ok := object.Key("DataSourceArn")
9899		ok.String(*v.DataSourceArn)
9900	}
9901
9902	if v.InputColumns != nil {
9903		ok := object.Key("InputColumns")
9904		if err := awsRestjson1_serializeDocumentInputColumnList(v.InputColumns, ok); err != nil {
9905			return err
9906		}
9907	}
9908
9909	if v.Name != nil {
9910		ok := object.Key("Name")
9911		ok.String(*v.Name)
9912	}
9913
9914	if v.Schema != nil {
9915		ok := object.Key("Schema")
9916		ok.String(*v.Schema)
9917	}
9918
9919	return nil
9920}
9921
9922func awsRestjson1_serializeDocumentRenameColumnOperation(v *types.RenameColumnOperation, value smithyjson.Value) error {
9923	object := value.Object()
9924	defer object.Close()
9925
9926	if v.ColumnName != nil {
9927		ok := object.Key("ColumnName")
9928		ok.String(*v.ColumnName)
9929	}
9930
9931	if v.NewColumnName != nil {
9932		ok := object.Key("NewColumnName")
9933		ok.String(*v.NewColumnName)
9934	}
9935
9936	return nil
9937}
9938
9939func awsRestjson1_serializeDocumentResourcePermission(v *types.ResourcePermission, value smithyjson.Value) error {
9940	object := value.Object()
9941	defer object.Close()
9942
9943	if v.Actions != nil {
9944		ok := object.Key("Actions")
9945		if err := awsRestjson1_serializeDocumentActionList(v.Actions, ok); err != nil {
9946			return err
9947		}
9948	}
9949
9950	if v.Principal != nil {
9951		ok := object.Key("Principal")
9952		ok.String(*v.Principal)
9953	}
9954
9955	return nil
9956}
9957
9958func awsRestjson1_serializeDocumentResourcePermissionList(v []types.ResourcePermission, value smithyjson.Value) error {
9959	array := value.Array()
9960	defer array.Close()
9961
9962	for i := range v {
9963		av := array.Value()
9964		if err := awsRestjson1_serializeDocumentResourcePermission(&v[i], av); err != nil {
9965			return err
9966		}
9967	}
9968	return nil
9969}
9970
9971func awsRestjson1_serializeDocumentRowLevelPermissionDataSet(v *types.RowLevelPermissionDataSet, value smithyjson.Value) error {
9972	object := value.Object()
9973	defer object.Close()
9974
9975	if v.Arn != nil {
9976		ok := object.Key("Arn")
9977		ok.String(*v.Arn)
9978	}
9979
9980	if v.Namespace != nil {
9981		ok := object.Key("Namespace")
9982		ok.String(*v.Namespace)
9983	}
9984
9985	if len(v.PermissionPolicy) > 0 {
9986		ok := object.Key("PermissionPolicy")
9987		ok.String(string(v.PermissionPolicy))
9988	}
9989
9990	return nil
9991}
9992
9993func awsRestjson1_serializeDocumentS3Parameters(v *types.S3Parameters, value smithyjson.Value) error {
9994	object := value.Object()
9995	defer object.Close()
9996
9997	if v.ManifestFileLocation != nil {
9998		ok := object.Key("ManifestFileLocation")
9999		if err := awsRestjson1_serializeDocumentManifestFileLocation(v.ManifestFileLocation, ok); err != nil {
10000			return err
10001		}
10002	}
10003
10004	return nil
10005}
10006
10007func awsRestjson1_serializeDocumentS3Source(v *types.S3Source, value smithyjson.Value) error {
10008	object := value.Object()
10009	defer object.Close()
10010
10011	if v.DataSourceArn != nil {
10012		ok := object.Key("DataSourceArn")
10013		ok.String(*v.DataSourceArn)
10014	}
10015
10016	if v.InputColumns != nil {
10017		ok := object.Key("InputColumns")
10018		if err := awsRestjson1_serializeDocumentInputColumnList(v.InputColumns, ok); err != nil {
10019			return err
10020		}
10021	}
10022
10023	if v.UploadSettings != nil {
10024		ok := object.Key("UploadSettings")
10025		if err := awsRestjson1_serializeDocumentUploadSettings(v.UploadSettings, ok); err != nil {
10026			return err
10027		}
10028	}
10029
10030	return nil
10031}
10032
10033func awsRestjson1_serializeDocumentServiceNowParameters(v *types.ServiceNowParameters, value smithyjson.Value) error {
10034	object := value.Object()
10035	defer object.Close()
10036
10037	if v.SiteBaseUrl != nil {
10038		ok := object.Key("SiteBaseUrl")
10039		ok.String(*v.SiteBaseUrl)
10040	}
10041
10042	return nil
10043}
10044
10045func awsRestjson1_serializeDocumentSheetControlsOption(v *types.SheetControlsOption, value smithyjson.Value) error {
10046	object := value.Object()
10047	defer object.Close()
10048
10049	if len(v.VisibilityState) > 0 {
10050		ok := object.Key("VisibilityState")
10051		ok.String(string(v.VisibilityState))
10052	}
10053
10054	return nil
10055}
10056
10057func awsRestjson1_serializeDocumentSheetStyle(v *types.SheetStyle, value smithyjson.Value) error {
10058	object := value.Object()
10059	defer object.Close()
10060
10061	if v.Tile != nil {
10062		ok := object.Key("Tile")
10063		if err := awsRestjson1_serializeDocumentTileStyle(v.Tile, ok); err != nil {
10064			return err
10065		}
10066	}
10067
10068	if v.TileLayout != nil {
10069		ok := object.Key("TileLayout")
10070		if err := awsRestjson1_serializeDocumentTileLayoutStyle(v.TileLayout, ok); err != nil {
10071			return err
10072		}
10073	}
10074
10075	return nil
10076}
10077
10078func awsRestjson1_serializeDocumentSnowflakeParameters(v *types.SnowflakeParameters, value smithyjson.Value) error {
10079	object := value.Object()
10080	defer object.Close()
10081
10082	if v.Database != nil {
10083		ok := object.Key("Database")
10084		ok.String(*v.Database)
10085	}
10086
10087	if v.Host != nil {
10088		ok := object.Key("Host")
10089		ok.String(*v.Host)
10090	}
10091
10092	if v.Warehouse != nil {
10093		ok := object.Key("Warehouse")
10094		ok.String(*v.Warehouse)
10095	}
10096
10097	return nil
10098}
10099
10100func awsRestjson1_serializeDocumentSparkParameters(v *types.SparkParameters, value smithyjson.Value) error {
10101	object := value.Object()
10102	defer object.Close()
10103
10104	if v.Host != nil {
10105		ok := object.Key("Host")
10106		ok.String(*v.Host)
10107	}
10108
10109	{
10110		ok := object.Key("Port")
10111		ok.Integer(v.Port)
10112	}
10113
10114	return nil
10115}
10116
10117func awsRestjson1_serializeDocumentSqlServerParameters(v *types.SqlServerParameters, value smithyjson.Value) error {
10118	object := value.Object()
10119	defer object.Close()
10120
10121	if v.Database != nil {
10122		ok := object.Key("Database")
10123		ok.String(*v.Database)
10124	}
10125
10126	if v.Host != nil {
10127		ok := object.Key("Host")
10128		ok.String(*v.Host)
10129	}
10130
10131	{
10132		ok := object.Key("Port")
10133		ok.Integer(v.Port)
10134	}
10135
10136	return nil
10137}
10138
10139func awsRestjson1_serializeDocumentSslProperties(v *types.SslProperties, value smithyjson.Value) error {
10140	object := value.Object()
10141	defer object.Close()
10142
10143	if v.DisableSsl {
10144		ok := object.Key("DisableSsl")
10145		ok.Boolean(v.DisableSsl)
10146	}
10147
10148	return nil
10149}
10150
10151func awsRestjson1_serializeDocumentStringList(v []string, value smithyjson.Value) error {
10152	array := value.Array()
10153	defer array.Close()
10154
10155	for i := range v {
10156		av := array.Value()
10157		av.String(v[i])
10158	}
10159	return nil
10160}
10161
10162func awsRestjson1_serializeDocumentStringParameter(v *types.StringParameter, value smithyjson.Value) error {
10163	object := value.Object()
10164	defer object.Close()
10165
10166	if v.Name != nil {
10167		ok := object.Key("Name")
10168		ok.String(*v.Name)
10169	}
10170
10171	if v.Values != nil {
10172		ok := object.Key("Values")
10173		if err := awsRestjson1_serializeDocumentStringList(v.Values, ok); err != nil {
10174			return err
10175		}
10176	}
10177
10178	return nil
10179}
10180
10181func awsRestjson1_serializeDocumentStringParameterList(v []types.StringParameter, value smithyjson.Value) error {
10182	array := value.Array()
10183	defer array.Close()
10184
10185	for i := range v {
10186		av := array.Value()
10187		if err := awsRestjson1_serializeDocumentStringParameter(&v[i], av); err != nil {
10188			return err
10189		}
10190	}
10191	return nil
10192}
10193
10194func awsRestjson1_serializeDocumentTag(v *types.Tag, value smithyjson.Value) error {
10195	object := value.Object()
10196	defer object.Close()
10197
10198	if v.Key != nil {
10199		ok := object.Key("Key")
10200		ok.String(*v.Key)
10201	}
10202
10203	if v.Value != nil {
10204		ok := object.Key("Value")
10205		ok.String(*v.Value)
10206	}
10207
10208	return nil
10209}
10210
10211func awsRestjson1_serializeDocumentTagColumnOperation(v *types.TagColumnOperation, value smithyjson.Value) error {
10212	object := value.Object()
10213	defer object.Close()
10214
10215	if v.ColumnName != nil {
10216		ok := object.Key("ColumnName")
10217		ok.String(*v.ColumnName)
10218	}
10219
10220	if v.Tags != nil {
10221		ok := object.Key("Tags")
10222		if err := awsRestjson1_serializeDocumentColumnTagList(v.Tags, ok); err != nil {
10223			return err
10224		}
10225	}
10226
10227	return nil
10228}
10229
10230func awsRestjson1_serializeDocumentTagList(v []types.Tag, value smithyjson.Value) error {
10231	array := value.Array()
10232	defer array.Close()
10233
10234	for i := range v {
10235		av := array.Value()
10236		if err := awsRestjson1_serializeDocumentTag(&v[i], av); err != nil {
10237			return err
10238		}
10239	}
10240	return nil
10241}
10242
10243func awsRestjson1_serializeDocumentTemplateSourceAnalysis(v *types.TemplateSourceAnalysis, value smithyjson.Value) error {
10244	object := value.Object()
10245	defer object.Close()
10246
10247	if v.Arn != nil {
10248		ok := object.Key("Arn")
10249		ok.String(*v.Arn)
10250	}
10251
10252	if v.DataSetReferences != nil {
10253		ok := object.Key("DataSetReferences")
10254		if err := awsRestjson1_serializeDocumentDataSetReferenceList(v.DataSetReferences, ok); err != nil {
10255			return err
10256		}
10257	}
10258
10259	return nil
10260}
10261
10262func awsRestjson1_serializeDocumentTemplateSourceEntity(v *types.TemplateSourceEntity, value smithyjson.Value) error {
10263	object := value.Object()
10264	defer object.Close()
10265
10266	if v.SourceAnalysis != nil {
10267		ok := object.Key("SourceAnalysis")
10268		if err := awsRestjson1_serializeDocumentTemplateSourceAnalysis(v.SourceAnalysis, ok); err != nil {
10269			return err
10270		}
10271	}
10272
10273	if v.SourceTemplate != nil {
10274		ok := object.Key("SourceTemplate")
10275		if err := awsRestjson1_serializeDocumentTemplateSourceTemplate(v.SourceTemplate, ok); err != nil {
10276			return err
10277		}
10278	}
10279
10280	return nil
10281}
10282
10283func awsRestjson1_serializeDocumentTemplateSourceTemplate(v *types.TemplateSourceTemplate, value smithyjson.Value) error {
10284	object := value.Object()
10285	defer object.Close()
10286
10287	if v.Arn != nil {
10288		ok := object.Key("Arn")
10289		ok.String(*v.Arn)
10290	}
10291
10292	return nil
10293}
10294
10295func awsRestjson1_serializeDocumentTeradataParameters(v *types.TeradataParameters, value smithyjson.Value) error {
10296	object := value.Object()
10297	defer object.Close()
10298
10299	if v.Database != nil {
10300		ok := object.Key("Database")
10301		ok.String(*v.Database)
10302	}
10303
10304	if v.Host != nil {
10305		ok := object.Key("Host")
10306		ok.String(*v.Host)
10307	}
10308
10309	{
10310		ok := object.Key("Port")
10311		ok.Integer(v.Port)
10312	}
10313
10314	return nil
10315}
10316
10317func awsRestjson1_serializeDocumentThemeConfiguration(v *types.ThemeConfiguration, value smithyjson.Value) error {
10318	object := value.Object()
10319	defer object.Close()
10320
10321	if v.DataColorPalette != nil {
10322		ok := object.Key("DataColorPalette")
10323		if err := awsRestjson1_serializeDocumentDataColorPalette(v.DataColorPalette, ok); err != nil {
10324			return err
10325		}
10326	}
10327
10328	if v.Sheet != nil {
10329		ok := object.Key("Sheet")
10330		if err := awsRestjson1_serializeDocumentSheetStyle(v.Sheet, ok); err != nil {
10331			return err
10332		}
10333	}
10334
10335	if v.UIColorPalette != nil {
10336		ok := object.Key("UIColorPalette")
10337		if err := awsRestjson1_serializeDocumentUIColorPalette(v.UIColorPalette, ok); err != nil {
10338			return err
10339		}
10340	}
10341
10342	return nil
10343}
10344
10345func awsRestjson1_serializeDocumentTileLayoutStyle(v *types.TileLayoutStyle, value smithyjson.Value) error {
10346	object := value.Object()
10347	defer object.Close()
10348
10349	if v.Gutter != nil {
10350		ok := object.Key("Gutter")
10351		if err := awsRestjson1_serializeDocumentGutterStyle(v.Gutter, ok); err != nil {
10352			return err
10353		}
10354	}
10355
10356	if v.Margin != nil {
10357		ok := object.Key("Margin")
10358		if err := awsRestjson1_serializeDocumentMarginStyle(v.Margin, ok); err != nil {
10359			return err
10360		}
10361	}
10362
10363	return nil
10364}
10365
10366func awsRestjson1_serializeDocumentTileStyle(v *types.TileStyle, value smithyjson.Value) error {
10367	object := value.Object()
10368	defer object.Close()
10369
10370	if v.Border != nil {
10371		ok := object.Key("Border")
10372		if err := awsRestjson1_serializeDocumentBorderStyle(v.Border, ok); err != nil {
10373			return err
10374		}
10375	}
10376
10377	return nil
10378}
10379
10380func awsRestjson1_serializeDocumentTimestampList(v []time.Time, value smithyjson.Value) error {
10381	array := value.Array()
10382	defer array.Close()
10383
10384	for i := range v {
10385		av := array.Value()
10386		av.Double(smithytime.FormatEpochSeconds(v[i]))
10387	}
10388	return nil
10389}
10390
10391func awsRestjson1_serializeDocumentTransformOperation(v types.TransformOperation, value smithyjson.Value) error {
10392	object := value.Object()
10393	defer object.Close()
10394
10395	switch uv := v.(type) {
10396	case *types.TransformOperationMemberCastColumnTypeOperation:
10397		av := object.Key("CastColumnTypeOperation")
10398		if err := awsRestjson1_serializeDocumentCastColumnTypeOperation(&uv.Value, av); err != nil {
10399			return err
10400		}
10401
10402	case *types.TransformOperationMemberCreateColumnsOperation:
10403		av := object.Key("CreateColumnsOperation")
10404		if err := awsRestjson1_serializeDocumentCreateColumnsOperation(&uv.Value, av); err != nil {
10405			return err
10406		}
10407
10408	case *types.TransformOperationMemberFilterOperation:
10409		av := object.Key("FilterOperation")
10410		if err := awsRestjson1_serializeDocumentFilterOperation(&uv.Value, av); err != nil {
10411			return err
10412		}
10413
10414	case *types.TransformOperationMemberProjectOperation:
10415		av := object.Key("ProjectOperation")
10416		if err := awsRestjson1_serializeDocumentProjectOperation(&uv.Value, av); err != nil {
10417			return err
10418		}
10419
10420	case *types.TransformOperationMemberRenameColumnOperation:
10421		av := object.Key("RenameColumnOperation")
10422		if err := awsRestjson1_serializeDocumentRenameColumnOperation(&uv.Value, av); err != nil {
10423			return err
10424		}
10425
10426	case *types.TransformOperationMemberTagColumnOperation:
10427		av := object.Key("TagColumnOperation")
10428		if err := awsRestjson1_serializeDocumentTagColumnOperation(&uv.Value, av); err != nil {
10429			return err
10430		}
10431
10432	default:
10433		return fmt.Errorf("attempted to serialize unknown member type %T for union %T", uv, v)
10434
10435	}
10436	return nil
10437}
10438
10439func awsRestjson1_serializeDocumentTransformOperationList(v []types.TransformOperation, value smithyjson.Value) error {
10440	array := value.Array()
10441	defer array.Close()
10442
10443	for i := range v {
10444		av := array.Value()
10445		if vv := v[i]; vv == nil {
10446			continue
10447		}
10448		if err := awsRestjson1_serializeDocumentTransformOperation(v[i], av); err != nil {
10449			return err
10450		}
10451	}
10452	return nil
10453}
10454
10455func awsRestjson1_serializeDocumentTwitterParameters(v *types.TwitterParameters, value smithyjson.Value) error {
10456	object := value.Object()
10457	defer object.Close()
10458
10459	{
10460		ok := object.Key("MaxRows")
10461		ok.Integer(v.MaxRows)
10462	}
10463
10464	if v.Query != nil {
10465		ok := object.Key("Query")
10466		ok.String(*v.Query)
10467	}
10468
10469	return nil
10470}
10471
10472func awsRestjson1_serializeDocumentUIColorPalette(v *types.UIColorPalette, value smithyjson.Value) error {
10473	object := value.Object()
10474	defer object.Close()
10475
10476	if v.Accent != nil {
10477		ok := object.Key("Accent")
10478		ok.String(*v.Accent)
10479	}
10480
10481	if v.AccentForeground != nil {
10482		ok := object.Key("AccentForeground")
10483		ok.String(*v.AccentForeground)
10484	}
10485
10486	if v.Danger != nil {
10487		ok := object.Key("Danger")
10488		ok.String(*v.Danger)
10489	}
10490
10491	if v.DangerForeground != nil {
10492		ok := object.Key("DangerForeground")
10493		ok.String(*v.DangerForeground)
10494	}
10495
10496	if v.Dimension != nil {
10497		ok := object.Key("Dimension")
10498		ok.String(*v.Dimension)
10499	}
10500
10501	if v.DimensionForeground != nil {
10502		ok := object.Key("DimensionForeground")
10503		ok.String(*v.DimensionForeground)
10504	}
10505
10506	if v.Measure != nil {
10507		ok := object.Key("Measure")
10508		ok.String(*v.Measure)
10509	}
10510
10511	if v.MeasureForeground != nil {
10512		ok := object.Key("MeasureForeground")
10513		ok.String(*v.MeasureForeground)
10514	}
10515
10516	if v.PrimaryBackground != nil {
10517		ok := object.Key("PrimaryBackground")
10518		ok.String(*v.PrimaryBackground)
10519	}
10520
10521	if v.PrimaryForeground != nil {
10522		ok := object.Key("PrimaryForeground")
10523		ok.String(*v.PrimaryForeground)
10524	}
10525
10526	if v.SecondaryBackground != nil {
10527		ok := object.Key("SecondaryBackground")
10528		ok.String(*v.SecondaryBackground)
10529	}
10530
10531	if v.SecondaryForeground != nil {
10532		ok := object.Key("SecondaryForeground")
10533		ok.String(*v.SecondaryForeground)
10534	}
10535
10536	if v.Success != nil {
10537		ok := object.Key("Success")
10538		ok.String(*v.Success)
10539	}
10540
10541	if v.SuccessForeground != nil {
10542		ok := object.Key("SuccessForeground")
10543		ok.String(*v.SuccessForeground)
10544	}
10545
10546	if v.Warning != nil {
10547		ok := object.Key("Warning")
10548		ok.String(*v.Warning)
10549	}
10550
10551	if v.WarningForeground != nil {
10552		ok := object.Key("WarningForeground")
10553		ok.String(*v.WarningForeground)
10554	}
10555
10556	return nil
10557}
10558
10559func awsRestjson1_serializeDocumentUpdateResourcePermissionList(v []types.ResourcePermission, value smithyjson.Value) error {
10560	array := value.Array()
10561	defer array.Close()
10562
10563	for i := range v {
10564		av := array.Value()
10565		if err := awsRestjson1_serializeDocumentResourcePermission(&v[i], av); err != nil {
10566			return err
10567		}
10568	}
10569	return nil
10570}
10571
10572func awsRestjson1_serializeDocumentUploadSettings(v *types.UploadSettings, value smithyjson.Value) error {
10573	object := value.Object()
10574	defer object.Close()
10575
10576	if v.ContainsHeader {
10577		ok := object.Key("ContainsHeader")
10578		ok.Boolean(v.ContainsHeader)
10579	}
10580
10581	if v.Delimiter != nil {
10582		ok := object.Key("Delimiter")
10583		ok.String(*v.Delimiter)
10584	}
10585
10586	if len(v.Format) > 0 {
10587		ok := object.Key("Format")
10588		ok.String(string(v.Format))
10589	}
10590
10591	if v.StartFromRow != 0 {
10592		ok := object.Key("StartFromRow")
10593		ok.Integer(v.StartFromRow)
10594	}
10595
10596	if len(v.TextQualifier) > 0 {
10597		ok := object.Key("TextQualifier")
10598		ok.String(string(v.TextQualifier))
10599	}
10600
10601	return nil
10602}
10603
10604func awsRestjson1_serializeDocumentVpcConnectionProperties(v *types.VpcConnectionProperties, value smithyjson.Value) error {
10605	object := value.Object()
10606	defer object.Close()
10607
10608	if v.VpcConnectionArn != nil {
10609		ok := object.Key("VpcConnectionArn")
10610		ok.String(*v.VpcConnectionArn)
10611	}
10612
10613	return nil
10614}
10615