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